Exploiting Schema and Documentation for Summarizing Relational Databases

2012 ◽  
pp. 77-90 ◽  
Author(s):  
Ammar Yasir ◽  
Mittapally Kumara Swamy ◽  
Polepalli Krishna Reddy
Keyword(s):  
Relational Databases

XML Modeling of Fuzzy Data with Relational Databases

2011 ◽  
Vol 34 (2) ◽  
pp. 291-303 ◽  
Author(s):  
Li YAN ◽  
Zong-Min MA ◽  
Jian LIU ◽  
Fu ZHANG
Keyword(s):  
Relational Databases ◽  
Fuzzy Data

XPERT : An XML Query Processing System using Relational Databases

2006 ◽  
Vol 13D (1) ◽  
pp. 1-10
Author(s):  
Min-Kyoung Jung ◽  
Dong-Kweon Hong
Keyword(s):  
Query Processing ◽  
Relational Databases ◽  
Processing System ◽  
Xml Query Processing

scholarly journals Bloom Filter-Based Parallel Architecture for Accelerating Equi-Join Operation on FPGA

Electronics ◽  
2021 ◽  
Vol 10 (15) ◽  
pp. 1778
Author(s):  
Binhao He ◽  
Meiting Xue ◽  
Shubiao Liu ◽  
Wei Luo
Keyword(s):  
Relational Databases ◽  
Parallel Architecture ◽  
Operation Time ◽  
Bloom Filter ◽  
Search Tree ◽  
Binary Search Tree ◽  
Maximum Acceleration ◽  
Data Intensive ◽  
Match Rate ◽  
Field Programmable

As one of the most important operations in relational databases, the join is data-intensive and time-consuming. Thus, offloading this operation using field-programmable gate arrays (FPGAs) has attracted much interest and has been broadly researched in recent years. However, the available SRAM-based join architectures are often resource-intensive, power-consuming, or low-throughput. Besides, a lower match rate does not lead to a shorter operation time. To address these issues, a Bloom filter (BF)-based parallel join architecture is presented in this paper. This architecture first leverages the BF to discard the tuples that are not in the join result and classifies the remaining tuples into different channels. Second, a binary search tree is used to reduce the number of comparisons. The proposed method was implemented on a Xilinx FPGA, and the experimental results show that under a match rate of 50%, our architecture achieved a high join throughput of 145.8 million tuples per second and a maximum acceleration factor of 2.3 compared to the existing SRAM-based join architectures.

Closed Sets of Boolean Terms in Relational Databases

1991 ◽  
Vol 14 (3) ◽  
pp. 367-385
Author(s):  
Andrzej Jankowski ◽  
Zbigniew Michalewicz
Keyword(s):  
Computational Complexity ◽  
Incomplete Information ◽  
Relational Databases ◽  
The Other ◽  
New Approach ◽  
Closed Sets ◽  
Null Value ◽  
Algebraic Operations

A number of approaches have been taken to represent compound, structured values in relational databases. We review a few such approaches and discuss a new approach, in which every set is represented as a Boolean term. We show that this approach generalizes the other approaches, leading to more flexible representation. Boolean term representation seems to be appropriate in handling incomplete information: this approach generalizes some other approaches (e.g. null value mark, null variables, etc). We consider definitions of algebraic operations on such sets, like join, union, selection, etc. Moreover, we introduce a measure of computational complexity of these operations.

scholarly journals Efficient local locking for massively multithreaded in-memory hash-based operators

2021 ◽  
Author(s):  
Bashar Romanous ◽  
Skyler Windh ◽  
Ildar Absalyamov ◽  
Prerna Budhkar ◽  
Robert Halstead ◽  
...  
Keyword(s):  
Relational Databases ◽  
Aggregation Operators ◽  
Main Memory ◽  
Paradigm Shifts ◽  
Multithreaded Processors ◽  
Cache Hierarchies ◽  
Processor Architectures ◽  
Spatial Locality ◽  
Content Addressable Memories ◽  
Multi Core Processor

AbstractThe join and group-by aggregation are two memory intensive operators that are affecting the performance of relational databases. Hashing is a common approach used to implement both operators. Recent paradigm shifts in multi-core processor architectures have reinvigorated research into how the join and group-by aggregation operators can leverage these advances. However, the poor spatial locality of the hashing approach has hindered performance on multi-core processor architectures which rely on using large cache hierarchies for latency mitigation. Multithreaded architectures can better cope with poor spatial locality by masking memory latency with many outstanding requests. Nevertheless, the number of parallel threads, even in the most advanced multithreaded processors, such as UltraSPARC, is not enough to fully cover the main memory access latency. In this paper, we explore the hardware re-configurability of FPGAs to enable deeper execution pipelines that maintain hundreds (instead of tens) of outstanding memory requests across four FPGAs-drastically increasing concurrency and throughput. We present two end-to-end in-memory accelerators for the join and group-by aggregation operators using FPGAs. Both accelerators use massive multithreading to mask long memory delays of traversing linked-list data structures, while concurrently managing hundreds of thread states across four FPGAs locally. We explore how content addressable memories can be intermixed within our multithreaded designs to act as a synchronizing cache, which enforces locks and merges jobs together before they are written to memory. Throughput results for our hash-join operator accelerator show a speedup between 2$$\times $$ × and 3.4$$\times $$ × over the best multi-core approaches with comparable memory bandwidths on uniform and skewed datasets. The accelerator for the hash-based group-by aggregation operator demonstrates that leveraging CAMs achieves average speedup of 3.3$$\times $$ × with a best case of 9.4$$\times $$ × in terms of throughput over CPU implementations across five types of data distributions.

Sign in / Sign up

Export Citation Format

Share Document