Search

Database Management Systems (DBMSs) provide access control mechanisms that allow database administrators (DBAs) to grant application programs access privileges to databases. Though such mechanisms are powerful, in practice finer-grained access control mechanism tailored to the semantics of the data stored in the DMBS is required as a first class defense mechanism against smart attackers. Hence, custom written applications which access databases implement an additional layer of access control. Therefore, securing a database alone is not enough for such applications, as attackers aiming at stealing data can take advantage of vulnerabilities in the privileged applications and make these applications to issue malicious database queries. An access control mechanism can only prevent application programs from accessing the data to which the programs are not authorized, but it is unable to prevent misuse of the data to which application programs are authorized for access. Hence, we need a mechanism able to detect malicious behavior resulting from previously authorized applications. In this paper, we present the architecture of an anomaly detection mechanism, DetAnom , that aims to solve such problem. Our approach is based the analysis and profiling of the application in order to create a succinct representation of its interaction with the database. Such a profile keeps a signature for every submitted query and also the corresponding constraints that the application program must satisfy to submit the query. Later, in the detection phase, whenever the application issues a query, a module captures the query before it reaches the database and verifies the corresponding signature and constraints against the current context of the application. If there is a mismatch, the query is marked as anomalous. The main advantage of our anomaly detection mechanism is that, in order to build the application profiles, we need neither any previous knowledge of application vulnerabilities nor any example of possible attacks. As a result, our mechanism is able to protect the data from attacks tailored to database applications such as code modification attacks, SQL injections, and also from other data-centric attacks as well. We have implemented our mechanism with a software testing technique called concolic testing and the PostgreSQL DBMS. Experimental results show that our profiling technique is close to accurate, requires acceptable amount of time, and the detection mechanism incurs low runtime overhead.

Automatic feature recognition aids downstream processes such as engineering analysis and manufacturing planning. Not all features can be defined in advance; a declarative approach allows engineers to specify new features without having to design algorithms to find them. Naive translation of declarations leads to executable algorithms with high time complexity. Database queries are also expressed declaratively; there is a large literature on optimizing query plans for efficient execution of database queries. Our earlier work investigated applying such technology to feature recognition, using a testbed interfacing a database system (SQLite) to a CAD modeler (CADfix). Feature declarations were translated into SQL queries which are then executed.The current paper extends this approach, using the PostgreSQL database, and provides several new insights: (i) query optimization works quite differently in these two databases, (ii) with care, an approach to query translation can be devised that works well for both databases, and (iii) when finding various simple common features, linear time performance can be achieved with respect to model size, with acceptable times for real industrial models. Further results also show how (i) lazy evaluation can be used to reduce the work performed by the CAD modeler, and (ii) estimating the time taken to compute various geometric operations can further improve the query plan. Experimental results are presented to validate our main conclusions. This paper describes a declarative feature recognizer which utilizes concepts from database query optimization.It gives a general way to translate feature definitions to efficient SQL query.It uses lazy evaluation to reduce the work performed by the CAD modeler.It also uses estimated cost of reorder various geometric computations to further improve performance.Our approach provides linear time performance with respect to model size for common features.

Data centers are well known to consume a large amount of energy. As databases are one of the major applications in a data center, building energy-aware database systems has become an active research topic recently. The quantification of the energy cost of database systems is an important task in design. In this paper, we report our recent efforts on this issue, with a focus on the energy cost estimation of query plans during query optimization. We start from building a series of physical models for energy estimation of individual relational operators based on their resource consumption patterns. As the execution of a query plan is a combination of multiple relational operators, we use the physical models as a basis for a comprehensive energy model for the entire query. To address the challenge of maintaining accuracy under system and workload dynamics, we develop an online scheme that dynamically adjusts model parameters based on statistical signal modeling. Our models are implemented in a real database management system and evaluated on a physical test bed. The results show that our solution achieves a high accuracy (worst-case error 13.7 percent) despite noises. Our models also help identify query plans with significantly higher energy efficiency.

This is an epoch of Big data, Cloud computing, Cloud Database Management techniques. Traditional database approaches are not suitable for such colossal amount of data. To overcome the limitations of RDBMS, Map Reduce codes can be considered as a probable solution for such huge amount of data processing. Map Reduce codes provide both scalability and reliability. Users till date can work snugly with traditional Database approaches such as SQL, MYSQL, ORACLE, DB2, etc., and they are not aware of Map Reduce codes. In this paper, we are proposing a model which can convert any RDBMS queries to Map Reduce codes. We also gear optimization technique which can improve the performance of such amalgam approach.

As most database users cannot precisely express their information needs in the form of database queries, it is challenging for database query interfaces to understand and satisfy their intents. Database systems usually improve their understanding of users' intents by collecting their feedback on the answers to the users' imprecise and ill-specified queries. Users may also learn to express their queries precisely during their interactions with the database system. In this paper, we report our progress on developing a formal framework for representing and understanding information needs in database querying and exploration. Our framework considers querying as a collaboration between the user and the database system to establish a mutual language for representing information needs. We formalize this collaboration as a signaling game between two potentially rational agents: the user and the database system. We believe that this framework naturally models the long-term interaction of users and database systems.

In order to make up the real-time performance of tracking and control information database, this paper design a kind of two-layer’s real-time data storage model based on memory database and relational database. In this article, the two-layer’s real-time data storage mechanism and life cycle are expounded in detail, analyzing and inducing the real-time data characteristic and storage strategy, putting forward the memory database’s self-adaptive index algorithm of T-tree index and hash index, and introducing the database synchronization mechanism between the memory database and relational database and so on. In this way, so as to improve and optimize the real-time, reliability and security of database, provides a reliable data guarantee for future expansion of the real-time application.

In order to facilitate and speed up the search of massive DNA databases, the database is indexed at the beginning, employing a mapping function. By searching through the indexed data structure, exact query hits can be identified. If the database is searched against an annotated DNA query, such as a known promoter consensus sequence, then the starting locations and the number of potential genes can be determined. This is particularly relevant if unannotated DNA sequences have to be functionally annotated. However, indexing a massive DNA database and searching an indexed data structure with millions of entries is a time-demanding process. In this paper, we propose a fast DNA database indexing and searching approach, identifying all query hits in the database, without having to examine all entries in the indexed data structure, limiting the maximum length of a query that can be searched against the database. By applying the proposed indexing equation, the whole human genome could be indexed in 10 hours on a personal computer, under the assumption that there is enough RAM to store the indexed data structure. Analysing the methodology proposed by Reneker, we observed that hits at starting positions [Formula: see text] are not reported, if the database is searched against a query shorter than [Formula: see text] nucleotides, such that [Formula: see text] is the length of the DNA database words being mapped and [Formula: see text] is the length of the query. A solution of this drawback is also presented.

Testing is essential for quality assurance of database applications. Achieving high code coverage of the database applications is important in testing. In practice, there may exist a copy of live databases that can be used for database application testing. Using an existing database state is desirable since it tends to be representative of real-world objects' characteristics, helping detect faults that could cause failures in real-world settings. However, to cover a specific program-code portion (e.g., block), appropriate program inputs also need to be generated for the given existing database state. To address this issue, in this paper, we propose a novel approach that generates program inputs for achieving high code coverage of a database application, given an existing database state. Our approach uses symbolic execution to track how program inputs are transformed before appearing in the executed SQL queries and how the constraints on query results affect the application's execution. One significant challenge in our problem context is the gap between program-input constraints derived from the program and from the given existing database state; satisfying both types of constraints is needed to cover a specific program-code portion. Our approach includes novel query formulation to bridge this gap. We incorporate the data-instantiation component in our framework to deal with the case that no effective program input values can be attained. We determine how to generate new records and populate them in the new database state such that the code along the path can be covered. We also extend our approach of program-input generation to test database applications including canonical queries and group-by queries. Our approach is loosely integrated into Pex, a state-of-the-art white-box testing tool for .NET from Microsoft Research. Empirical evaluations on two real database applications show that our approach assists Pex to generate program inputs that achieve higher code coverage than the program inputs generated by Pex without our approach's assistance.

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.

The design of data mining system in database is researched. Vast amounts of information contained in the database, and the data show the diversity of characteristics, resulting in lower efficiency of data mining in database, which database brought greater difficulties to information query. To avoid these shortcomings, database performance optimization method based on cloud computing is proposed. The model of cloud computing data relationship is established to describe the connection between related data inthe database, thus providing the basis for data query. The load state of data nodes is calculated to enable rapid information inquiryin the database. Experimental results show that using this algorithm to optimize data inquiry in database can improve the efficiency of informationinquiry indatabase effectively.

As the relational database is applied widely, how to protect the sensitive data and state secrets has become a problem which needs to be solved urgently. The conventional relational database encryption technology not only reduces the system’s performance, but also results that we can not quickly inquire the encryption data through the original index mechanism due to the loss of the original partial order relation among data. This paper proposes a kind of relational database encryption technology based on the main memory database. It has not only realized the transparent encryption, decryption and ciphertext storage of the relational database, but also still retained the original response and retrieval performance. This technical proposal has very strong adaptability as well as strong practice guidance meaning for protecting the internet business data and the war-industry informative state secrets.

Nowadays, a variety of database systems coexist and the application softwares access and operation for database is often custom-written, which can lead to more complicated cross-database access. Through analysis of the operational process of the database middleware, adding the generic database query middleware eQueryMW which can shield the difference of the data source to the traditional three-tier architecture as the middleware level can realize the access of relational heterogeneity database, providing a unified database query interface and cross-database integration method for the users.

In practical relational database, there are many tables that the values of their most fields have only two kinds and the values of the left fields are all discrete. For this kind of table, the paper presented a new logical storage structure utilizing binary field to compress the data volume and by making binary operations and SQL statements combined to realize the new database operations to enhance their executing efficiency. Experimental results showed that the new storage structure indeed greatly reduced the physical storage space and optimized the performance of the relational database.

SUMMARY The database services on cloud are appearing as an attractive way of outsourcing databases. When a database is deployed on a cloud database service, the data security and privacy becomes a big concern for users. A straightforward way to address this concern is to encrypt the database. However, after encryption, the database cannot be easily queried. In this paper, we propose a nonlinear order preserving scheme for indexing encrypted data, which facilitates the range queries over encrypted databases. The scheme is secure even there are a large number of duplicates in plaintexts. Moreover, our scheme allows the programmability of basic indexing expressions and thus provides the capability of hiding the distribution of plaintexts from the distribution of indexes. This scheme is suitable for long-standing databases because its use does not need any assumption on the characteristics of database data, such as their distribution, range and number, which may change dramatically over time.Copyright © 2013 John Wiley & Sons, Ltd.

Background/Objectives: Since most of the enterprises are still using relational database as the back-end database, XML Enabled Database (XED) plays an important role to ensure the seamless integration of XML technology via the relational database. Methods/Statistical analysis: In this paper, we will compare the features supported in XED product, namely Microsoft SQL Server, Oracle and IBM DB2. In order to do so, we propose and develop XR-Gine to measure the performance of these storages. Findings: Some of the performance comparisons include speed of storing, retrieving, and updating functions in the database approaches. Based on the results obtained, the best performance of storing evaluation is Oracle. On the other hand, in terms of query retrieval, Microsoft SQL Server outperforms especially in supporting huge datasets, which is a necessity with the overwhelming data produced across the web nowadays. Application/Improvements: The results generated by the engine are beneficial to aid the community to choose the appropriate XED database system.

Database clustering is a well-established technology to improve the availability and scalability of a database service. Query replication and log replication are two popular methods for propagating database updates across a cluster of database servers. An important issue that received relatively scant attention and is the focus of this paper is how to add a new server to an active-active database cluster with minimum service disruption while maximizing the cluster's request processing concurrency during run time. Even though log replication allows attaching a new database server without stopping the attached database cluster's service, the asynchronous nature of its operation is incompatible with active-active clusters, where every cluster node is designed to share the load of servicing incoming read query queries. In contrast, query replication is synchronous and thus could readily support active-active clustering, but most existing query replication implementations need to halt a cluster's service when attaching a new server. In this paper, we present a database resynchronization scheme that achieves the best of both worlds: leveraging log replication to minimize the service disruption time associated with addition of new servers, while applying query replication during run time to maximize the parallelism of read query processing, and demonstrate its effectiveness in a product-grade database engine, PostgreSQL.

Indexes are very important in query data from database, especially in large scale of data. Rational use of index technology is essential in improving database's query performance. SQL Server database use B+ tree structure to store indexes. Clustered index can change data's physical position. Both of Clustered index and non-clustered index depend on B+ index tree to query data. Non-clustered index should depend on either data row pointer or clustered index key to find the retrieve data. Two algorithms are used in SQL Server database to retrieve data. Usually table scan should be avoided except that large-scale of data involved in the query or most columns of the table are covered in the query. Table seek has a better efficiency for most cases. Some principle of how to use index properly are given in this paper. The paper also suggest that functions, calculations and some query conditions should to be avoided or replaced , or to be used as little as possible in query statement to make indexes effective.

Extracting information from a database system becomes a primary obligation. More and more we are forced to recognize the importance of providing easy access to information stored in a database system. However existing tools that allow users to query database using database query languages such as SQL (Structured Query Language) are difficult for non-experts users. Wherefore asking questions to databases in natural language is a very simple method that can provide powerful improvements to the use of data stored in databases. This paper presents the Architecture and the implementation of a generic natural language interface based on machine learning approach for a relational database. The advantage of this interface is that it functions independently of the database domain and automatically improves through experience its knowledge base.

Database management systems are used to store the data and to perform various operations on the data such as insertion, deletion and updation which is stored on the databases. To access the data from the databases, it is required to use a structured query language which is difficult to learn for the naive users. In this paper, designing of a generic natural language interface to the database management systems for retrieving the knowledge through structured query language is attempted. The proposed system can be used to retrieve the data from single columns and multiple columns. The system can also works on various types of queries which can join multiple tables with selected attributes with multiple conditions. The proposed system is independent of the underlying database tables and the relations among the tables. It is also independent of the natural language used to query the database.

This research presents an optimization for generic query mode for any database application. It is an enhancement for a previously research "Improving the Query Mode and its Interface for Relational Database Applications". The research improved its intelligence more than expected. In the previous research the algorithm was intelligent in the sense that it answers most of the possible queries or questions that may arise in the user’s mind without the need or support of the application developer but there was a restriction for that which is the user can't query about any computed field. This research added this feature to the algorithm regardless the depth of the computed field. The meaning of the depth of the computed field is how many times of the computed field in an equation needs to be transformed so that it contains no computed fields. It has been implemented using PowerBuilder (release 11.5) as a front end tool and Adaptive Server Anywhere (one of Sybase products) as a database engine. This research describes the design of the optimized intelligent generic query mode and its interface.

There are two obvious methods to map a two-dimension relational database table onto a one-dimensional storage interface: store the table row-by-row, or store the table column-by-column. Traditionally, database system implementations and research have focused on the row-by row data layout, since it performs best on the most common application for database systems: business transactional data processing. However, there are a set of emerging applications for database systems for which the row-by-row layout performs poorly. These applications are more analytical in nature, whose goal is to read through the data to gain new insight and use it to drive decision making and planning. In this paper, we study the poor performance of row-by-row data layout for these emerging applications, and evaluate the column-by-column data layout opportunity as a solution to this problem. The solution will be analyzed and represented by graph. At the end of the paper we will see the comparative performance of Oracle 10g and MSSQLServer database.

During processing database query or dealing with huge amounts of data, the conventional query method is not only a waste of resources but also may perform repeated or useless operations which may cause the database overburdened even. For solving the problem of time-consuming in conventional database query, this paper presented a more convenient solution to the problem in conventional database queries. This paper constructed an XML document to simulate the database and transformed the database query into the XML queries. Experiments showed that speed can be significantly improved for database query and better results can be obtained.

Due to the recent advancement of cloud computing, the research on database outsourcing has been actively done. Moreover, the number of users who utilize Location-based Services(LBS) has been increasing with the development in w ireless communication technology and mobile devices. Therefore, LBS providers attempt to outsource their spatial database to service provider, in order to reduce costs for data storage and management. However, because unauthorized access to sensitive data is possible in spatial database outsourcing, it is necessary to study on the preservation of a user's privacy. Thus, we, in this paper, propose a spatial data encryption scheme to produce outsourced database from an original database. We also propose a k-Nearest Neighbor(k-NN) query processing algorithm that efficiently performs k-NN by using the outsourced database. Finally, we show from performance analysis that our algorithm outperforms the existing one.

XML has recently emerged as the leading medium for data storage and data transfer over the World Wide Web due to its adaptable structure and flexibility in defining the tags. Many organizations had adopted XML as the principal facet in their online business applications. On the other hand, relational database is still widely used as the back-end database in most organizations. The diversity of these models need to be taken into account to ensure transparent and seamless integration. In this paper, we propose s-XML, an effective mapping scheme to bridge XML and relational database. Experimental results indicate that (1) s-XML is robust in terms of database storage and data loading; (2) s-XML processes query efficiently for complex chain and twig queries; and (3) s-XML is able to support large and skew-structured dataset as compared to relational DTD, Attribute and Edge approaches.

This article using three kinds of storage structure combined to store field data, that is memory database, relational database and document management system. This paper also gives the basic realization scheme of real-time database, and using Windows dynamic link library technology and the global shared memory technology to establish real-time database system.

Through the in-depth study of the existing distributed database query processing technology, this paper proposes a distributed database query processing program. This program optimizes the existing query processing, stores the commonly used query results according to the query frequency, to be directly used by the subsequent queries or used as intermediate query results, thus avoiding possible transmission of a large number of data, thereby reducing the query time and improving query efficiency.

Problem statement: The databases introduce the digital era the fact that requirement to maintain large and ample data. The growth of information development and improvement that pursued it transformed the databases into a global reality. This study enquired and described the vital role of storing the context data to an appropriate database in the area of context aware computing. It also addson limitations of the existing relational and object relational databases with respect to context aware computing. Approach: This article examines traditional database like relational database, object relational database and spatial database. It helps to make an optimal decision while choosing the database for context aware applications. Results: All the traditional databases are compared with context aware features like semantic support, ease of transaction of large data, query optimization, reasoning support, formality, scalability, spatial data and xml support. Conclusion: This study confirmed that using object relational database along with ontology is more apt for storing the context data for context aware computing applications.

We consider the problem of similarity queries in biological network databases. Given a database of networks, similarity query returns all the database networks whose similarity (i.e. alignment score) to a given query network is at least a specified similarity cutoff value. Alignment of two networks is a very costly operation, which makes exhaustive comparison of all the database networks with a query impractical. To tackle this problem, we develop a novel indexing method, named RINQ (Reference-based Indexing for Biological Network Queries). Our method uses a set of reference networks to eliminate a large portion of the database quickly for each query. A reference network is a small biological network. We precompute and store the alignments of all the references with all the database networks. When our database is queried, we align the query network with all the reference networks. Using these alignments, we calculate a lower bound and an approximate upper bound to the alignment score of each database network with the query network. With the help of upper and lower bounds, we eliminate the majority of the database networks without aligning them to the query network. We also quickly identify a small portion of these as guaranteed to be similar to the query. We perform pairwise alignment only for the remaining networks. We also propose a supervised method to pick references that have a large chance of filtering the unpromising database networks. Extensive experimental evaluation suggests that (i) our method reduced the running time of a single query on a database of around 300 networks from over 2 days to only 8 h; (ii) our method outperformed the state of the art method Closure Tree and SAGA by a factor of three or more; and (iii) our method successfully identified statistically and biologically significant relationships across networks and organisms. Contact: ggulsoy@cise.ufl.edu; tamer@cise.ufl.edu Supplementary information: Supplementary data are available at Bioinformatics online.

The typical workload in a database system consists of a mix of multiple queries of different types that run concurrently. Interactions among the different queries in a query mix can have a significant impact on database performance. Hence, optimizing database performance requires reasoning about query mixes rather than considering queries individually. Current database systems lack the ability to do such reasoning. We propose a new approach based on planning experiments and statistical modeling to capture the impact of query interactions. Our approach requires no prior assumptions about the internal workings of the database system or the nature and cause of query interactions, making it portable across systems. To demonstrate the potential of modeling and exploiting query interactions, we have developed a novel interaction-aware query scheduler for report-generation workloads. Our scheduler, called QShuffler, uses two query scheduling algorithms that leverage models of query interactions. The first algorithm is optimized for workloads where queries are submitted in large batches. The second algorithm targets workloads where queries arrive continuously, and scheduling decisions have to be made online. We report an experimental evaluation of QShuffler using TPC-H workloads running on IBM DB2. The evaluation shows that QShuffler, by modeling and exploiting query interactions, can consistently outperform (up to 4x) query schedulers in current database systems.

In this paper, we take Oracle as the example of relational database, and Caché as a post-relational database. We implement the performance test between relational database and post-relational database in HIS. The results prove post-relational are much more efficient than relational database.

It is widely recognized that the integration of information retrieval (IR) and database (DB) techniques provides users with a broad range of high quality services. Along this direction, IR-styled m-keyword query processing over a relational database in an rdbms framework has been well studied. It finds all hidden interconnected tuple structures, for example connected trees that contain keywords and are interconnected by sequences of primary/foreign key relationships among tuples. A new challenging issue is how to monitor events that are implicitly interrelated over an open-ended relational data stream for a user-given m-keyword query. Such a relational data stream is a sequence of tuple insertion/deletion operations. The difficulty of the problem is related to the number of costly joins to be processed over time when tuples are inserted and/or deleted. Such cost is mainly affected by three parameters, namely, the number of keywords, the maximum size of interconnected tuple structures, and the complexity of the database schema when it is viewed as a schema graph. In this paper, we propose new approaches. First, we propose a novel algorithm to efficiently determine all the joins that need to be processed for answering an m-keyword query. Second, we propose a new demand-driven approach to process such a query over a high speed relational data stream. We show that we can achieve high efficiency by significantly reducing the number of intermediate results when processing joins over a relational data stream. The proposed new techniques allow us to achieve high scalability in terms of both query plan generation and query plan execution. We conducted extensive experimental studies using synthetic data and real data to simulate a relational data stream. Our approach significantly outperforms existing algorithms. © 2010 Springer-Verlag.

Problem statement: Many existing database applications manage time-varying data. These database applications are referred to as temporal databases or time-oriented database applications that are considered as repositories of time-dependent data. Many proposals have been introduced for developing time-oriented database applications, some of which suggest building support for Temporal Database Management Systems (TDBMS) on top of existing non-temporal DBMSs, while others suggest modifying the models of exiting DBMSs or building TDBMS from scratch. Approach: This study addressed several issues concerning developing a technique that enables database designers to understand the way in which time-varying behavior can be modeled and mapped into tabular form. Results: Conventional DBMSs do not have the capability to record and process time-varying aspects of the real world. With growing sophistication of DBMS applications, the lack of temporal support in conventional DBMS raises serious problems when used to develop temporal database. The technique of understanding how to think about time and represent it in formal systems is the topic of this study. We examined how to implement time-varying application in the SQL structured query language by introducing temporal data concepts that need to be simulated in DBMSs which lack temporal supports. We proposed a temporal data model that combines the features of previous temporal models and that reduces the cost of memory storage. Conclusion: We proposed a technique for implementing temporal database on top of exiting non-temporal DBMS. This technique includes five main areas. These areas are temporal database conceptual design, temporal database logical design, integrity constraints preventions in temporal database, modifying and querying temporal database. We proposed a data model for the temporal database based on the data models which are discussed in literature.

A central feature of relational database management systems is the ability to define multiple different views over an underlying database schema. Views provide a method of defining access control to the underlying database, since a view exposes a part of the database and hides the rest. Views also provide logical data independence to application programs that access the database. For most cases, the process of specifying the desired views in SQL is typically tedious and error-prone. While numerous tools exist to support developers in debugging program code, we are not aware of any tool that supports developers in verifying the correctness of their views defined in SQL.

Complex databases are challenging to explore and query by users unfamiliar with their schemas. Enterprise databases often have hundreds of inter-linked tables, so even when extensive documentation is available, new users must spend a considerable amount of time understanding the schema before they can retrieve any information from the database. The problem is aggravated if the documentation is missing or outdated, which may happen with legacy databases. In this paper we identify limitations of previous approaches to address this vexing problem, and propose a principled approach to summarizing the contents of a relational database, so that a user can determine at a glance the type of information it contains, and the main tables in which that information resides. Our approach has three components: First, we define the importance of each table in the database as its stable state value in a random walk over the schema graph, where the transition probabilities depend on the entropies of table attributes. This ensures that the importance of a table depends both on its information content, and on how that content relates to the content of other tables in the database. Second, we define a metric space over the tables in a database, such that the distance function is consistent with an intuitive notion of table similarity. Finally, we use a Weighted k -Center algorithm under this distance function to cluster all tables in the database around the most relevant tables, and return the result as our summary. We conduct an extensive experimental study on a benchmark database, comparing our approach with previous methods, as well as with several hybrid models. We show that our approach not only achieves significantly higher accuracy than the previous state of the art, but is also faster and scales linearly with the size of the schema graph.

Database systems have a large number of configuration parameters that control memory distribution, I/O optimization, costing of query plans, parallelism, many aspects of logging, recovery, and other behavior. Regular users and even expert database administrators struggle to tune these parameters for good performance. The wave of research on improving database manageability has largely overlooked this problem which turns out to be hard to solve. We describe iTuned, a tool that automates the task of identifying good settings for database configuration parameters. iTuned has three novel features: (i) a technique called Adaptive Sampling that proactively brings in appropriate data through planned experiments to find high-impact parameters and high-performance parameter settings, (ii) an executor that supports online experiments in production database environments through a cycle-stealing paradigm that places near-zero overhead on the production workload; and (iii) portability across different database systems. We show the effectiveness of iTuned through an extensive evaluation based on different types of workloads, database systems, and usage scenarios.

Standard search engines have made the task of looking for information relatively easy and painless. In sharp contrast, most relational database interfaces make searching for information complicated and confusing - mainly because they require knowledge of specialized languages and the schema of the underlying data. In this paper, the authors describe a technique that supports the querying of a relational database (RDB) using a standard search engine. The technique involves expressing database queries through URLs. The technique also includes the development of a special wrapper that can process the URL-query and generate web pages that contain the answer to the query as well as links to additional data. By following these specialized links, a standard web crawler can index the RDB along with all the URL-queries. Once the content and their corresponding URL-queries have been indexed, a user may submit keyword queries through a standard search engine and receive the most current information in the database. Moreover, the system has been recently augmented with standard query syntax and metadata that allows users to formulate more expressive queries and search engines to index the database more efficiently. The authors describe the technique for making database content accessible to the web; they provide an evaluation of a prototype system that shows the correctness of our approach; and they present experimental results that show how adding metadata can improve the overall efficiency of the search.

Forms-based query interfaces are widely used to access databases today. The design of a forms-based interface is often a key step in the deployment of a database. Each form in such an interface is capable of expressing only a very limited range of queries. Ideally, the set of forms as a whole must be able to express all possible queries that any user may have. Creating an interface that approaches this ideal is surprisingly hard. In this paper, we seek to maximize the ability of a forms-based interface to support queries a user may ask, while bounding both the number of forms and the complexity of any one form. Given a database schema and content we present an automated technique to generate a good set of forms that meet the above desiderata. While a careful analysis of real or expected query workloads are useful in designing the interface, these query sets are often unavailable or hard to obtain prior to the database even being deployed. Hence generating a good set of forms just using the database itself is a challenging yet important problem. Our experimental analysis shows that our techniques can create a reasonable set of forms, one that can express 60--90% of user queries, without any input from the database administrator. Human experts, without support from software such as ours, are often unable to support as high a fraction of user queries.

The performance of the mysql and oracle database systems have been compared for a selection of astronomy queries using large catalogues of up to a billion objects. The queries tested are those expected from the astronomy community: general database queries, cone searches, neighbour finding and cross matching. The catalogue preparation, sql query formulation and database performance is presented. Most of the general queries perform adequately when appropriate indexes are present in the database. Each system performs well for cone search queries when the Hierarchical Triangular Mesh spatial index is used. Neighbour finding and cross matching are not well supported in a database environment when compared to software specifically developed to solve these problems.

Objectives: Performance optimization is an ever end process. It requires continuous monitoring and special attention. Widely known fact that 60% of the performance problems are direct result of the inefficient queries. Method of Analysis: SQL Query is one of the most essential parts of application performance. Over the period, inefficient queries pull down the performance in live applications gradually. To achieve better application performance, proper database design and efficient query are needed. Most of the database systems provide expected performance in early stage and drastically will come down, once the data volume is increased and database becomes large size. Findings: Real performances of database systems can be assessed only during the applications are in live Database administrator and query developers cannot make sure 100% performance issues during the database design and query writing. Lot of issues will come mostly in post deployment in particular, when database has heavy transactions per day. There are multiple approaches available in the market to provide the solution for database performance. But, none of the mechanism is available to find out the performance bottleneck proactively. Also, solving performance issues is very painful and time-consuming. Improvement: This paper proposes various novel approaches to identify the performance bottleneck upfront and demonstrates the solution for the same.

In the present computing and fast growing world, information plays a key role in humans day to day life. Information can be stored in databases in an organized manner and SQL allows users to access process and manage data on database. But not all users are accustomed to writing SQL queries. This resulted in need for non-sophisticated users to access the database using natural language. A Natural Language Interface for Database (NLIDB) acts as an intelligent interface for database which allows users to access the database by typing requests in their natural language. The paper is going to discuss about a NLIDB system based on HMM. The system contains two modules: linguistic module and database module. Linguistic module makes uses of various Natural Language Processing (NLP) techniques which are used to identify tokens that correspond to the constraints and predicates required to build possible SELECT, WHERE and FROM clauses. The output of linguistic module is passed to database module. Identified tokens are then mapped to SQL query tokens using a query translation algorithm. A template is being used to generate corresponding SQL query. If the algorithm fails to identify sufficient details, a query prediction module based on HMM identifies the attributes and predicates list. The system used either a template based system that produce nearly 100% correct result to user query or prediction module that generate a highest probable result that matches to the user query. No situation exists in which the system fails to produce a result to the NL query.

This paper analyzes the problem of heterogeneous database and synchronization mechanism in enterprise data integration, provides a heterogeneous database integrated approach, then link up to a database center by web service, It provides a transparent unified interface. Users can not only query the database of the center, but also add, delete, update operation, and synchronize to the source database, at the same time, the source database client data and structure changes can be synchronized to the central database. Finally, the key technology and an example is given to show that how the framework is used in practical application.

Due to the emergence of cloud computing and big data applications, modern software systems are becoming more dependent on the underlying database management systems (DBMSs) for data integrity and management. Since DBMSs are very complex and each technology has some implementation-specific differences, DBMSs are usually used as black boxes by software developers, which allow better adaption and abstraction of different database technologies. For example, Object-Relational Mapping (ORM) is one of the most popular database abstraction approaches that developers use. Using ORM, objects in Object-Oriented languages are mapped to records in the DBMS, and object manipulations are automatically translated to SQL queries. Despite ORM's convenience, there exists impedance mismatches between the Object-Oriented paradigm and the relational DBMSs. Such impedance mismatches may result in developers writing inefficiently and/or incorrectly database access code. Thus, this thesis proposes several approaches to improve the quality of database-centric software systems by looking at the application source code. We focus on troubleshooting and detecting inefficient (i.e., performance problems) and incorrect (i.e., functional problems) database accesses in the source code, and we prioritize the detected problems based on severity. Through case studies on large commercial and open source systems, we plan to demonstrate the value of improving the quality of database-centric software systems from a new perspective - helping developers access the database more efficiently and accurately.

Database Management Systems (DBMSs) provide access control mechanisms that allow database administrators (DBA) to grant application programs access privileges to databases. However, securing the database alone is not enough, as attackers aiming at stealing data can take advantage of vulnerabilities in the privileged applications and make applications to issue malicious database queries. Therefore, even though the access control mechanism can prevent application programs from accessing the data to which the programs are not authorized, it is unable to prevent misuse of the data to which application programs are authorized for access. Hence, we need a mechanism able to detect malicious behavior resulting from previously authorized applications. In this paper, we design and implement an anomaly detection mechanism, DetAnom, that creates a profile of the application program which can succinctly represent the application's normal behavior in terms of its interaction (i.e., submission of SQL queries) with the database. For each query, the profile keeps a signature and also the corresponding constraints that the application program must satisfy to submit that query. Later in the detection phase, whenever the application issues a query, the corresponding signature and constraints are checked against the current context of the application. If there is a mismatch, the query is marked as anomalous. The main advantage of our anomaly detection mechanism is that we need neither any previous knowledge of application vulnerabilities nor any example of possible attacks to build the application profiles. As a result, our DetAnom mechanism is able to protect the data from attacks tailored to database applications such as code modification attacks, SQL injections, and also from other data-centric attacks as well. We have implemented our mechanism with a software testing technique called concolic testing and the PostgreSQL DBMS. Experimental results show that our profiling technique is close to accurate, and requires acceptable amount of time, and that the detection mechanism incurs low run-time overhead.

In today's world, IT industry faces several problems related to performance engineering in database optimization field. There are almost 80% IT projects of industry lies in maintenance phase. Nowadays, we generally design database in a way which in reality works good only at initial stages of database development. We generally do load testing to test behavior of database system after few years. But unknowingly we were not aware of the fact the data growth rate is increasing dynamically. Day by day this data keeps increasing with time. Data growing rate had become so high. There are several problems coming up related to slowness of applications and it reduces performance of database. This paper will furnish the idea of optimized database which internally decide what will be the volume of database few years down the line. What if database will be artificially intelligent in terms of performance problem? We will be designing an algorithm which automatically decides logical as well as actual load on system and change the behavior of queries which actually execute in database whenever there is request for data from any source. With the help of one plug-in we can incorporate this feature in database.

A significant amount of recent research in Computer Science Education has focused on studying block-based programming. In this approach, computer programs are created by connecting blocks and the blocks' shapes determine the permitted connections. The focus is on the program's logic instead of its syntax. This paper introduces DBSnap, a web-based application to build database queries, particularly relational algebra queries, by snapping blocks. DBSnap fully supports the construction of intuitive database query trees, which is one of the most effective approaches to teach database queries. DBSnap is also highly dynamic and shows the query results as the query is being built. The user can also inspect, at any time, the intermediate results of any query node. This paper presents DBSnap's design and implementation details, an evaluation of its effectiveness as a learning environment, and a thorough comparison with alternative ways to teach query languages. DBSnap is publicly available and aims to have the same transformational effect on database learning as previous block-based systems had on traditional programming learning.

We consider the problem of a client performing privacy-preserving range queries to a server’s database. We propose a cryptographic model for the study of such protocols, by expanding previous well-studied models of keyword search and private information retrieval to the range query type and to incorporate a multiple-occurrence attribute column in the database table.

Most commercial Web sites dynamically generate their contents through a three-tier server architecture composed of a Web server, an application server, and a database server. In such an architecture, the database server easily becomes a bottleneck to the overall performance. In this paper, we propose WDBAccel, a high-performance database server accelerator that significantly improves the throughput of database processing. WDBAccel eliminates costly, complex query processing needed to obtain query results by reusing the results from previous queries for subsequent queries. This differentiates WDBAccel from other database cache systems, which employ traditional query processing. WDBAccel further improves its performance by fully utilizing main memory as the primary storage. This paper presents the design and implementation of the WDBAccel as well as the results of performance evaluation with a prototype.

Object-Oriented Technology is an important discipline in the field of software engineering in general and it is, therefore, natural to ask whether it is relevant to the field of database management in particular and what that relevance is. There is, however, no consensus on answer to these questions. Some authorities believe that object oriented database systems will take over the world replacing relational system whereas others believe that they are suited only to certain very specific problems and will never capture more than a small fraction of the overall market. Object-Oriented technology represents real world very well, focusing on data rather than procedure and gives more security to data. Also, it is safe from unauthorized use of data because it provides three access specifiers viz. private, public and protected and strictly provides security to data in database. This technology also provides function as well as data together so that the data can be manipulated by the given function. In this paper, we show that how the data is more secure in object-oriented database than in relational database and also why do we migrate from RDBMS into OODBMS.

Fundamentally, semantic grid database is about bringing globally distributed databases together in order to coordinate resource sharing and problem solving in which information is given well-defined meaning, and DartGrid II is the implemented database gird system whose goal is to provide a semantic solution for integrating database resources on the Web. Although many algorithms have been proposed for optimizing query-processing in order to minimize costs and/or response time, associated with obtaining the answer to query in a distributed database system, database grid query optimization problem is fundamentally different from traditional distributed query optimization. These differences are shown to be the consequences of autonomy and heterogeneity of database nodes in database grid. Therefore, more challenges have arisen for query optimization in database grid than traditional distributed database. Following this observation, the design of a query optimizer in DartGrid II is presented, and a heuristic, dynamic and parallel query optimization approach to processing query in database grid is proposed. A set of semantic tools supporting relational database integration and semantic-based information browsing has also been implemented to realize the above vision.

Commercial database management systems (DBMSs) have historically seen very limited use within the scientific computing community. One reason for this absence is that previous database systems lacked support for the extensible data structures and performance features required within a high-performance computing context. However, database vendors have recently enhanced the functionality of their systems by adding object extensions to the relational engine. In principle, these extensions allow for the representation of a rich collection of scientific datatypes and common statistical operations. Utilizing these new extensions, this paper presents a study of the suitability of incorporating two popular scientific formats, NetCDF and HDF, into an object-relational system. To assess the performance of the database approach, a series of solution variables from a regional weather forecast model are used to build representative small, medium and large databases. Common statistical operations and array element queries are then performed using the object-relational database, and the execution timings are compared against native NetCDF and HDF operations.