Search

Database access logs are the starting point for many forms of database administration, from database performance tuning, to security auditing, to benchmark design, and many more. Unfortunately, query logs are also large and unwieldy, and it can be difficult for an analyst to extract broad patterns from the set of queries found therein. Clustering is a natural first step towards understanding the massive query logs. However, many clustering methods rely on the notion of pairwise similarity, which is challenging to compute for SQL queries, especially when the underlying data and database schema is unavailable. We investigate the problem of computing similarity between queries, relying only on the query structure. We conduct a rigorous evaluation of three query similarity heuristics proposed in the literature applied to query clustering on multiple query log datasets, representing different types of query workloads. To improve the accuracy of the three heuristics, we propose a generic feature engineering strategy, using classical query rewrites to standardize query structure. The proposed strategy results in a significant improvement in the performance of all three similarity heuristics.

Although graph databases have great potential to directly represent huge and complex network structures, such as social and logistics networks, they currently do not perform well enough. To achieve a two-orders-of-magnitude performance improvement on graph database queries, the authors propose caching the graph database in distributed GPUs connected with a 10-Gbit Ethernet (10GbE) network. Property read, traverse, and graph search queries are accelerated by 25.9, 252.4, and 383.2 times, respectively, compared to those using Neo4j for a huge graph consisting of 3.2 million nodes whose degree is 100.

The notion of database outsourcing enables the data owner to delegate the database management to a cloud service provider (CSP) that provides various database services to different users. Recently, plenty of research work has been done on the primitive of outsourced database. However, it seems that no existing solutions can perfectly support the properties of both correctness and completeness for the query results, especially in the case when the dishonest CSP intentionally returns an empty set for the query request of the user. In this paper, we propose a new verifiable auditing scheme for outsourced database, which can simultaneously achieve the correctness and completeness of search results even if the dishonest CSP purposely returns an empty set. Furthermore, we can prove that our construction can achieve the desired security properties even in the encrypted outsourced database. Besides, the proposed scheme can be extended to support the dynamic database setting by incorporating the notion of verifiable database with updates.

Mobile visual search systems typically compare a query image against a database of annotated images for accurate object recognition. On-server database matching can search a large database hosted in the cloud, but the query latency could suffer with slow network transmissions or server congestion . On-device database matching can ensure fast recognition responses regardless of network or server conditions , but a small amount of memory on the mobile device can severely limit the number of images that can be stored in an on- device database. This paper presents a new hybrid system that combines the advantages of on-device and on-server database matching. At the core of this system, we first develop a compact and discriminative global signature to characterize each image. Our global signature uses an optimized local feature count that is derived from a statistical analysis of the retrieval performance . We additionally create two extensions that exploit color information within images and relationships between similar database images to improve retrieval accuracy. Then, we propose methods for efficient interframe coding of a sequence of global signatures which are extracted from the viewfinder frames on the mobile device. A low bitrate stream of global signatures can be sent to the server at an uplink bitrate of less than 2 kbps to broaden the search range of the current query and to update the on-device database to help future queries.

Network function virtualization is considered one of the key technologies for developing future mobile networks. In this paper, we propose a theoretical framework to evaluate the performance of a Long-Term Evolution (LTE) virtualized mobility management entity (vMME) hosted in a data center. This theoretical framework consists of 1) a queuing network to model the vMME in a data center and 2) analytic expressions to estimate the overall mean system delay and the signaling workload to be processed by the vMME. We validate our mathematical model by simulation. One direct use of the proposed model is vMME dimensioning, i.e., to compute the number of vMME processing instances to provide a target system delay given the number of users in the system. Additionally, the paper includes a scalability analysis of the system. In our study, we consider the billing model and a data center setup of Amazon Elastic Compute Cloud service and estimate the processing time of MME processing instances for different LTE control procedures experimentally. For the considered setup, our results show that the vMME is scalable for signaling workloads up to 37 000 LTE control procedures per second for a target mean system delay of 1 ms. The system design and database performance assumed imposes this limit in the system scalability., This work was supported in part by the Spanish Ministry of Economy and Competitiveness and the European Regional Development Fund (project TIN2013-46223-P) and in part by the Spanish Ministry of Education, Culture, and Sport under FPU Grant 13/04833.

Interactive database exploration is a key task in information mining. However, users who lack SQL expertise or familiarity with the database schema face great difficulties in performing this task. To aid these users, we developed the QueRIE system for personalized query recommendations. QueRIE continuously monitors the user's querying behavior and finds matching patterns in the system's query log, in an attempt to identify previous users with similar information needs. Subsequently, QueRIE uses these “similar” users and their queries to recommend queries that the current user may find interesting. In this work we describe an instantiation of the QueRIE framework, where the active user's session is represented by a set of query fragments. The recorded fragments are used to identify similar query fragments in the previously recorded sessions, which are in turn assembled in potentially interesting queries for the active user. We show through experimentation that the proposed method generates meaningful recommendations on real-life traces from the SkyServer database and propose a scalable design that enables the incremental update of similarities, making real-time computations on large amounts of data feasible. Finally, we compare this fragment-based instantiation with our previously proposed tuple-based instantiation discussing the advantages and disadvantages of each approach.

Targeted deployment of hardware accelerators can improve the throughput and energy efficiency of large-scale data processing. Data partitioning is a critical operation for manipulating large datasets and is often the limiting factor in database performance. A hardware-software streaming framework offers a seamless execution environment for streaming accelerators such as the Hardware-Accelerated Range Partitioner (HARP). Together, the streaming framework and HARP provide an order of magnitude improvement in partitioning and energy performance.

Databases are an important workload for modern commodity microarchitectures. Achieving the best performance requires that careful attention be paid to the underlying architecture, including instruction and data cache usage, data layout, branch prediction, and multithreading. Specialized commodity microarchitectures, such as graphics cards and network processors, have also been investigated as effective query coprocessors. This paper presents a survey of recent architecture-sensitive database research. The insights gained from optimizing database performance on modern microarchitectures are also applicable to other domains, particularly those that are similarly data intensive.

In most current database systems, data is updated in-place. In order to support recovery and increase performance, write-ahead logging is used. This logging defers the in-place updates. However, sooner or later, the updates have to be applied to the database. Even if this is done as a batch operation, it can result in many nonsequential writes. In order to avoid this, another approach is to eliminate the database completely and use a log-only approach. In this case, the log is written contiguously to the disk, in a no-overwrite way using large blocks. When using the log-only approach keeping previous versions comes almost for free, and this approach is therefore particularly interesting for transaction-time temporal object database systems. Although the log-only approach in its basic form is relatively straightforward, it is not trivial to support features such as steal/no-force buffer management, fuzzy checkpointing, and fast commit. We describe, in detail, algorithms and strategies for object and log management that make support for these features possible.

The next-generation mobile network will support terminal mobility, personal mobility, and service provider portability, making global roaming seamless. A location-independent personal telecommunication number (PTN) scheme is conducive to implementing such a global mobile system. However, the nongeographic PTNs coupled with the anticipated large number of mobile users in future mobile networks may introduce very large centralized databases. This necessitates research into the design and performance of high-throughput database technologies used in mobile systems to ensure that future systems will be able to carry efficiently the anticipated loads. This paper proposes a scalable, robust, efficient location database architecture based on the location-independent PTNs. The proposed multitree database architecture consists of a number of database subsystems, each of which is a three-level tree structure and is connected to the others only through its root. By exploiting the localized nature of calling and mobility patterns, the proposed architecture effectively reduces the database loads as well as the signaling traffic incurred by the location registration and call delivery procedures. In addition, two memory-resident database indices, memory-resident direct file and T-tree, are proposed for the location databases to further improve their throughput. Analysis model and numerical results are presented to evaluate the efficiency of the proposed database architecture. Results have revealed that the proposed database architecture for location management can effectively support the anticipated high user density in the future mobile networks.

The execution of a client/server application involving database access requires a sequence of database transaction events (or, T-events), called a transaction sequence (or, T-sequence). A client/server database application may have nondeterministic behavior in that multiple executions thereof with the same input may produce different T-sequences. We present a framework for testing all possible T-sequences of a client/server database application. We first show how to define a T-sequence in order to provide sufficient information to detect race conditions between T-events. Second, we design algorithms to change the outcomes of race conditions in order to derive race variants, which are prefixes of other T-sequences. Third, we develop a prefix-based replay technique for race variants derived from T-sequences. We prove that our framework can derive all the possible T-sequences in cases where every execution of the application terminates. A formal proof and an analysis of the proposed framework are given. We describe a prototype implementation of the framework and present experimental results obtained from it.

Increasingly, for extensibility and performance, special purpose application code is being integrated with database system code. Such application code has direct access to database system buffers, and as a result, the danger of data being corrupted due to inadvertent application writes is increased. Previously proposed hardware techniques to protect from corruption require system calls, and their performance depends on details of the hardware architecture. We investigate an alternative approach which uses codewords associated with regions of data to detect corruption and to prevent corrupted data from being used by subsequent transactions. We develop several such techniques which vary in the level of protection, space overhead, performance, and impact on concurrency. These techniques are implemented in the Dali main-memory storage manager, and the performance impact of each on normal processing is evaluated. Novel techniques are developed to recover when a transaction has read corrupted data caused by a bad write and gone on to write other data in the database. These techniques use limited and relatively low-cost logging of transaction reads to trace the corruption and may also prove useful when resolving problems caused by incorrect data entry and other logical errors., © Elsevier

In personal communication services (PCS), the complete location information and subscribers' profiles are kept in a database called the home location register (HLR). Another database, the visitor location register (VLR), is used to store partial location information. When a mobile user is called, the system queries the HLR to determine the location of the called party. Distributed databases have been introduced to improve the efficiency of querying the HLR. This paper presents an alternative means of constructing a distributed database. The proposed database design employs fixed pointers to link distributed data. Each database contains a portion of the system's information as well as several pointers. The pointers identify the location of real data, enabling the system to obtain the required information efficiently. The database of the proposed design is markedly smaller than the fully distributed databases since each database of the proposed design stores only partial information. Subscriber information is stored only in one database, thus allowing a single database, rather than multiple databases, to be updated. The single update presented herein notably reduces the signal traffic load. If the caller is in the registration area of some HLR, which holds the called party's information, the response time is significantly decreased since the transactions are served only by the local database. This phenomenon is referred to as the calling locality. The proposed method effectively shares the database and the network loading that originates from several databases' tracking mobile users in a PCS system. According to the results presented, this method is highly effective for systems with a heavy load and high calling locality. The single update feature of the proposed design reduces the traffic in the signaling link and the processing load of a database. However, the proposed method includes no fault tolerance and therein differs from the fully distributed design.

The paper begins by discussing bottlenecks to users accessing Web sites. It goes on to consider database structure, tables and indexes. Also considered are query syntax, the role of application servers and their numbers. The paper concludes with a discussion of network architecture and content quantity.

Hyperlog is a declarative, graph based language that supports database querying and update. It visualizes schema information, data, and query output as sets of nested graphs, which can be stored, browsed, and queried in a uniform way. Thus, the user need only be familiar with a very small set of syntactic constructs. Hyperlog queries consist of a set of graphs that are matched against the database. Database updates are supported by means of programs consisting of a set of rules. The paper discusses the formulation, evaluation, expressiveness, and optimization of Hyperlog queries and programs. We also describe a prototype implementation of the language and we compare and contrast our approach with work in a number of related areas, including visual database languages, graph based data models, database update languages, and production rule systems.

A heterogeneous distributed database environment integrates a set of autonomous database systems to provide global database functions. A flexible transaction approach has been proposed for the heterogeneous distributed database environments. In such an environment, flexible transactions can increase the failure resilience of global transactions by allowing alternate (but in some sense equivalent) executions to be attempted when a local database system fails or some subtransactions of the global transaction abort. We study the impact of compensation, retry, and switching to alternative executions on global concurrency control for the execution of flexible transactions. We propose a new concurrency control criterion for the execution of flexible and local transactions, termed F-serializability, in the error-prone heterogeneous distributed database environments. We then present a scheduling protocol that ensures F-serializability on global schedules. We also demonstrate that this scheduler avoids unnecessary aborts and compensation.

Although embedded systems share many characteristics with their desktop and server counterparts, the unique advantages, limitations, and requirements of the applications they run demand a careful selection process and tailored implementation. The key strategy in choosing database tools for embedded systems is to focus on the application's requirements. Embedded database products vary widely from vendor to vendor. Some will do less than a particular application needs, some will do much more. By surveying the choices carefully, you can choose the tool that most closely matches your requirements. After choosing the operating system, hardware platform, and database software for a new embedded system, you must design a system that runs reliably with little or no human intervention. Unlike desktop and server systems, embedded systems cannot ask for operator help when the application encounters a problem. Finally, performance matters. Designing for performance up front, and evaluating it once you've built the application, is crucial. Fortunately, you can choose from a variety of techniques for evaluating and improving performance in database applications. To arrive at the best embedded-database-system solution, you must select the product that best matches your specific needs, then integrate that solution with your application. Start this process by evaluating which services your embedded application will provide.

Dynacore's project objective is to provide tools for the remote operation of large physics experiments. Our group concentrates on the design of a remote control room for the Textor-94 plasma-physics experiment, which will incorporate a distributed database, accessible with Corba over Internet. During normal operation, Textor-94 generates hundreds of megabytes of measurement data within the few seconds of a plasma shot. These shots are generated approximately every ten minutes, in total around 30 shots per day. A database will make the measurement data available to scientists, both at the experiment and in remote control rooms, which can be located in different countries, within minutes after the acquisition. Fast access to the database and a high data-storage speed are, therefore, of utmost importance. We have defined a set of data objects, which allow storage of virtually any kind of Textor measurement data. An Objectivity object-oriented database is used to store these objects. We have also designed an architecture in which database clients access the measurement database solely via data managers with Corba-interfaces. The data managers introduce security into the database, and also hide details of the database implementation for the users. An object manager provides clients with a central starting point, and distributes the total database load in an intelligent way over all available data-managers.

An approach to organizing storage in database systems is presented that, under a wide range of conditions, saves both storage space and processing time. Text values in a database are replaced by short, fixed-length, rank-preserving numeric tokens. The actual values are stored in separate, non-redundant storage. Database operations that depend only on the relative magnitude of data values can be performed directly on the tokens. Tokenization is shown to improve database performance most in situations where there are a lot of ad hoc queries and a low volume of database insertions relative to other operations.

The research in materialization of derived data elements has dealt so far with the if issue of whether to physically store derived data elements. In the active database area, there has been some research on the how issue. We deal with the when issue, devising an optimization model to determine the optimal materialization strategy. The decision problem confronted by the optimization model deals with devising the materialization strategy that consists of a set of interdependent decisions about each derived data element. Each decision relates to two issues: Should the value of a derived data element be persistent? What is the required level of consistency of a derived value with respect to its derivers? For each derived data element, the decision is based on both its local properties and its interdependencies with other derived values. The optimization model is based on a heuristic algorithm that finds a local optimum in O(N/sup 2/) and a monitor that obtains feedback about the actual database performance. This optimization model is general and is not specific to any data model. Our experimental results show that a predictor for the optimal solution cannot be obtained in any intuitive or analytic way, due to the complexity of the involved considerations; thus, there is no obvious way to achieve these results without using the optimization model. This fact is a strong motivation for applying such an optimization model.

Given N request streams and L/spl les/N LRU caches, the cache assignment problem asks to which cache each stream should be assigned in order to minimize the overall miss rate. An efficient solution to this problem is provided, based on characterizing each stream using the stack reference model and characterizing the interaction of the streams using a bursty stream model. It is shown that for Bernoulli (purely random) mixing of streams, the optimal cache assignment is to have one cache per stream. In practice streams are mixed in a way that is much "burstier" than can be represented by the Bernoulli model. Therefore a method is presented for superposition of bursty streams. The performance of the methods developed for bursty stream superposition and cache assignment are tested using trace data obtained from the database system DB2. The resulting cache assignment recommendations are then applied to the DB2 system, and considerable performance improvement is found to result.

In a heterogeneous database system, a query for one type of database system (i.e., a source query) may have to be translated to an equivalent query (or queries) for execution in a different type of database system (i.e., a target query). Usually, for a given source query, there is more than one possible target query translation. Some of them can be executed more efficiently than others by the receiving database system. Developing a translation procedure for each type of database system is time-consuming and expensive. We abstract a generic hierarchical database system (GHDBS) which has properties common to database systems whose schema contains hierarchical structures (e.g., System 2000, IMS, and some object-oriented database systems). We develop principles of query translation with GHDBS as the receiving database system. Translation into any specific system can be accomplished by a translation into the general system with refinements to reflect the characteristics of the specific system. We develop rules that guarantee correctness of the target queries, where correctness means that the target query is equivalent to the source query. We also provide rules that can guarantee a minimum number of target queries in cases when one source query needs to be translated to multiple target queries. Since the minimum number of target queries implies the minimum number of times the underlying system is invoked, efficiency is taken into consideration. >

This paper describes the design of a relational database and associated command structure for an accelerated-life-test facility. The primary goals of the design were to: (1) improve data integrity, and (2) provide a complete and consistent historical record of reliability test results. The intended reader is the engineer who wants to understand the issues involved in automating the reliability-data collection and reporting process. The paper: (1) shows (via the story of a particular reliability database design) in a tutorial fashion how to use system requirements and the formalisms of the relational model to create a database system for engineering tests; and (2) serves as a guide for developing relational database applications for other engineering and production activities. The paper makes three primary contributions by showing: (a) a practical method for constructing a relational database. The method is based on an IDEFO representation of the testing process, which is easier for the database novice to understand and implement than the usual approaches of data flow or entity-relationship diagrams. (b) The value of a particular database structure for maintaining engineering test database integrity: a table for test measurements, a table for kinds of test measurements, and a table for test measurement procedures. (c) How to write data entry/reporting application programs that maintain data integrity and ease the user's input burden. While specific issues in reliability testing are discussed, the methodology to construct the database and user interface applies broadly. >

In addition to maintaining database consistency as in conventional databases, real-time database systems must also handle transactions with timing constraints. While transaction response time and throughput are usually used to measure a conventional database system, the percentage of transactions satisfying the deadlines or a time-critical value function is often used to evaluate a real-time database system. Scheduling real-time transactions is far more complex than traditional real-time scheduling in the sense that (1) worst case execution times are typically hard to estimate, since not only CPU but also I/O requirement is involved; and (2) certain aspects of concurrency control may not integrate well with real-time scheduling. In this paper, we first develop a taxonomy of the underlying design space of concurrency control including the various techniques for achieving serializability and improving performance. This taxonomy provides us with a foundation for addressing the real-time issues. We then consider the integration of concurrency control with real-time requirements. The implications of using run policies to better utilize real-time scheduling in a database environment are examined. Finally, as timing constraints may be more important than data consistency in certain hard realtime database applications, we also discuss several approaches that explore the nonserializable semantics of real-time transactions to meet the hard deadlines. >

Transaction time is used for time stamping object values to record their database history and formulate a zero information loss model for database transactions. The model consists of three components, a data history store, an update store, and a query store. In such a model, the effect of a past transaction (a query or an update) can be determined at any time. Additionally, the update and query stores make it possible to reconstruct the circumstances of updates and the information divulged in queries. Such a model is suitable for the design of secure, easy-to-audit database systems. >

A multiback-end database supercomputer, or MDBS, that embodies the architecture and performance of an experimental database computer and a number of database processors and their corresponding database stores, is discussed. Two studies are described. One focused on the design and architecture of the microprocessor-based MDBS, and the other on the performance and benchmark results for various loads and configurations. >

Design experiments demonstrating that low-cost, simple, effective distribution energy management systems (EMSs) may be implemented with a minimum of vendor software are described. The experiments provide a relational database solution to distribution automation and define the database procedures necessary to generate a power flow database. The description of the database for the equipment as well as the database for each application is maintained within one database. Since the database selected (PARADOX) supports a distributed network, the database does not have to reside within one large database engine (mainframe). The experiments also solve power flow equations for the distribution system as implemented with a generalized spreadsheet program. Present spreadsheet programs can solve systems of equations as well as generalized optimization problems. The user full-graphic interface is most easily implemented with a package such as AutoCAD, currently used by many electric utilities. Such an interface is easy to implement with very little training. >

Database query languages and their use for programming nontraditional applications, such as engineering and artificial intelligence applications, are discussed. In such environments, database programs are used to code applications that work over large data sets residing in databases. Optimizing such programs then becomes a necessity. An examination is made of various optimization techniques, and transformations are suggested for improving the performance of database programs. These transformations result in new equivalent database programs with better space and time performance. Several of these techniques apply to classical query languages, although extended query languages which include an iteration operator are specifically discussed. >

The use of a language-oriented data structure for describing the data required for the real-time control and operation of power systems is demonstrated. The proposed database capitalizes on the fact that power networks and their attributes are hierarchically structured in the operational sense. The fundamental properties of the database are described first, and the steps required to generate such a database through a 'grid data language' are then demonstrated through a practical example. >

We present a methodology for structured database decomposition based on the relational data model. It is argued that in the distributed database environment, structured database decomposition is attractive both for efficiency and for database security considerations. Techniques for parallel processing and hashed access of structurally decomposed database are presented. Techniques for structured database decomposition to support multiple user views are also described. Structured database decomposition is most advantageous in a query only database environment with stable user views, although dynamic updates can also be handled using techniques described in this paper.

Concurrency control algorithms for database systems are usually regarded as methods for synchronizing Read and Write operations. Such methods are judged to be correct if they only produce serializable executions. However, Reads and Writes are sometimes inaccurate models of the operations executed by a database system. In such cases, serializability does not capture all aspects of concurrency control executions. To capture these aspects, we describe a proof schema for analyzing concurrency control correctness. We illustrate the proof schema by presenting two new concurrency algorithms for distributed database systems.

A database file system is the low-level part of a database management system that handles data storage, indexing, concurrency control, transaction control, and recovery. This article describes a structure for a database file system that encapsulates important design decisions into separate modules. This permits a choice of implementations for each module. A database file system can be generated for a particular application by choosing the appropriate implementation for each module from a catalog (one from column A, one from column B, etc.). This approach can be both more flexible and more efficient than the usual approach of building a monolithic database file system to satisfy everyone. The challenge is to partition the database file system functions into modules that hide enough information to allow flexibility, but not so much as to be inefficient. The structure described here, which is biased towards information hiding, is an initial attempt at a suitable partitioning. An experimental system, XFS, was built to test this structure.

Achieving efficiency in database management functions is a fundamental problem underlying many computer applications. Efficiency is difficult to achieve using the traditional general-purpose von Neumann processors. Recent advances in microelectronic technologies have prompted many new research activities in the design, implementation, and application of database machines which are tailored for processing database management functions. To build an efficient system, the software algorithms designed for this type of system need to be tailored to take advantage of the hardware characteristics of these machines. Furthermore, special hardware units should be used, if they are cost- effective, to execute or to assist the execution of these software algorithms.

Database machine architectures have been proposed as a promising alternative to improve database system performance, control, and flexibility. While many claims have been made for the database machine concept, few studies have been made to test the performance advantages and disadvantages of a database machine in an application environment. A comprehensive benchmark study comparing the performance of database systems on a conventional computer system and a database machine is reported in this paper. The results show the database machine architecture to have superior performance in most cases. The performance advantage is sensitive to the communication line speed between the host computer and the database machine. The effects of line speed are studied and displayed in the benchmark results. A summary of the similarities and differences between the architectures based upon our benchmark results completes the paper.

Conventional database design techniques rely heavily on the designer's skill and experience, which are neither efficient nor effective for large, realistic design problems. A computer design aid can help by storing many design parameters and performing simple preprocessing before design decisions are made. In this paper, we report on the development of such a system.

Traditionally, a database manager tracks only transactions — an insufficient way to maintain a complete history. This multilevel system tracks three history levels: character, transaction, and global action.

Localized information referencing is a long-known and much-exploited facet of program behavior. The existence of such behavior in the data accessing patterns produced by database management systems is not currently supported by empirical results. We present experimental results which demonstrate that in certain environments and under certain important applications, locality of reference is an undeniable characteristic of the information accessing behavior of a hierarchical database management system. Furthermore, database locality of reference is in a sense more regular, predictable, and hence, more exploitable than the localized reference activity found in programs in general. The implications of these results for the performance enhancement and workload characterization of database management systems are discussed.

Strategies for secure query processing multilevel-security database management systems are proposed. They are carried out by query modification, a technique that has been used for enforcing integrity constraints and providing view mechanisms. The technique consists of replacing the query the user presents with one that, when evaluated, will perform the desired function. In the case of a view mechanism, the names of views referenced in the query are replaced by the definitions of the views in terms of base relations. The basic strategy and two variants-adding environmental information and using graphs-are described. The performance of the strategies is examined. >

This paper describes a simulation study of the effect of runtime schema interpretation in a network data model database management system. To perform database operations, programmers use a data manipulation language which supports calls to the data manipulation routines. The data manipulation routines utilize database descriptors from the schema to determine which operations on the database are to be performed for a given actual parameter to the procedure. Current database systems perform the binding of schema descriptors in the data manipulation routines at run-time by interpretation. A niumber of researchers are studying methods to precompute the information required to determine the correct function to execute rather than using run-time interpretation.

This paper presents the concept of a model of database skeleton which is used to represent user's knowledge on the meaning of the data. The logical database synthesis pfoblem is then formulated as a problem of convetting a partially specified database skeleton to a completely specified-one, which corresponds to one of several data models. Approaches to optimal logical database synthesis for the relational database are then considered.

The concept of the data utility as a database system capable of supporting a data model, a large-scale on-line store, and concurrent user access has emerged in recent years. New technology can make the notion of database computers—a specialized hardware system for database use—a viable one. A summary of previous activities and a discussion of the state of the art of database computers is given. An attempt is made to suggest guidelines for future database computer architecture research.

Design considerations of a database computer are presented in this paper. The overall architecture of the computer as well as the organization of its individual components are discussed. Several key concepts which are vital to database management are incorporated in the design and organization of the components. The concepts of tracks-in-parallel read-out and logic-per-some-track processing are provided in an on-line database store for the purpose of achieving high-volume content-addressability. The use of auxiliary information about the database for access precision and control has resulted in the design of a structure memory, an array of content-addressable memory and processor pairs, for large collections of indices. The choice of technologies for the implementation of these components is considered in terms of their cost and performance. Modified moving-head disk technology is chosen in order to support the very large on-line database store. Emerging technologies such as magnetic bubbles and CCD's are chosen for the structure memory on the basis of their matching performance with the on-line database store and their capability for parallel-in-blocks-and-serial-within-block processing. Five other important components are also disdissed in the paper. Their role in the database computer and relationship with the structure memory and on-line database store are delineated.

This paper describes the design and implementation of a special-purpose distributed data management system. The design and implementation were parts of a study to evaluate the database management needs of software-defined logical subnetworks. The paper describes the authorization model used to define logical subnetworks and the related subnetwork management transactions. The definition of the subnetworks and their service capabilities are stored in a distributed database. The distributed database architecture and the implemented software architecture are described. The requirement to design and implement within a specific time frame has kept the design simple, but the nature of the application dictated that we consider many aspects of the more general distributed data-management problem. The database management issues that are addressed in this paper, in the context of transaction processing, include multicopy updates, concurrency control, and crash recovery. A version of the primary node concept for multicopy updates was adopted. Data inconsistencies, created by premature termination of transaction processing (e.g., system crash), are detected and removed by the software.

The controlled-generator model of P.J. Ramadge and W.M. Wonham (1988) is used to formulate the concurrent execution of transactions in database systems as a control problem for a partially observed discrete-event dynamical system. The control objectives of this problem (for concurrency control and recovery) and the properties of some important transaction scheduling techniques are characterized in terms of the language generated by the controlled process and in terms of the stage of an ideal complete-information scheduler. Results about the performance of these techniques are presented. >

The optimal selection of secondary indexes asks for the quantitative evaluation of the performance of a number of candidate secondary indexes in order to determine the particular combination of indexes which satisfies the anticipated user transactions at a minimal cost. Previous studies determine the optimal selection by assuming that the cost of satisfying a query using a secondary index is not affected by the existence of other indexes in the database. This assumption is realistic when the inverted file organization is used to organize secondary indexes. The main reason is that inverted files do not alter the size of the file. However, the assumption is not valid when the next most popular method for structuring secondary indexes is used, namely, the multilist database structures. This is so, because each multilist increases the size of the file. This paper studies the secondary index selection problem by making the assumption that the multilist organization is utilized to structure secondary indexes and develops a dynamic programming algorithm to solve it. The practical significance of the study lies in the fact that multilists can be easily implemented on network databases.

This paper presents an architectural design for a back-end database machine (DBM) suitable for supporting multiple-user, on-line, very large relational database systems (systems with capacities larger than 1010 bytes). This machine is called the Michigan Relational Database Machine (MIRDM). In designing such a machine a structured approach is followed. First, the DBM's proposed so far are reviewed using a novel classification scheme. Second, this review, the very large relational database system requirements, and the restrictions imposed by the current and near-future state of technology are used to formulate a set of design guidelines. Consequently, an architecture for a cost-effective DBM that meets this set of guidelines is synthesized. Some of the algorithms developed for implementing the primitives of the new machine are also presented. Finally, we highlight some of the important differences between the new DBM and some of the previously proposed ones.

A database management system was designed and implemented for the No. 5 Electronic Switching System. It is a specialized database management system based on the relational data model. The database is distributed and subject to stringent real-time constraints and reliability requirements. The system characteristics, capabilities, and design philosophy are described herein.

The design of DIRECT, a multiprocessor organization for supporting relational database management systems is presented. DIRECT has a multiple-instruction multiple-data stream (MIMD) architecture. It can simultaneously support both intra-query and inter-query concurrency. The number of processors assigned to a query is dynamically determined by the priority of the query, the type and number of relational algebra operations it contains, and the size of the relations referenced. Since DIRECT iS a virtual memory machine, the maximum relation size is not limited to that of the associative memory as in some other database machines. Concurrent updates are controlled through the use of locks on relations which are maintained by a controlling processor.

The semijoin provides a means of reducing the amount of data transmission among sites in a distributed database system. Previously the semijoin has been studied mainly for reducing communication cost in an environment with global public communication networks. In a local area system, however, wide bandwidth is usually available and the communication cost is virtually negligible. In view of this, we adopt a simplified model of a local area network, imposing no constraint on the transmission line capacity and the communication processing capability at each site. For this model, an efficient algorithm for obtaining the shortest semijoin schedule, in the sense of minimizing the total number of semijoin transmissions, is developed. It is based on a schedule diagram newly introduced to represent the semijoin schedule.

When a crash occurs in a transaction processing system, the database can enter an unacceptable state. To continue the processing, the recovery system has three tasks: 1) verification of the database state for acceptability, 2) restoration of an acceptable database state, and 3) restoration of an acceptable history of transaction processing. Unfortunately these tasks are not trivial and the computational complexity of the algorithms for most of them is either NP-complete or NP-hard. In this paper we discuss the concepts and design issues of a construct called database integrity block (DIB). The implementation of this construct allows for efficient verification of the database state by employing a set of integrity assertions and restoration of transaction history by utilizing any database restoration technique such as audit trail or differential file. This paper presents approximation algorithms for minimizing the costs of evaluation of integrity assertions by modeling the problem as the directed traveling salesman problem, and presents a methodology to compare the costs of audit trail and differential file techniques for database restoration. The applicability of integrity verification research to the problem of multiple-query optimization is also included.