In recent decades, there has been a significant increase in the use of social networks, smart devices, and sensors that led to high-volume temporal data generation. Temporal modeling and querying of this huge data have been essential for effective querying and retrieval. However, custom temporal models have the problem of generalizability, whereas the extended temporal models require users to adapt to new querying languages. In this paper, we propose our novel Cartempian model by storing temporal interval as Cartesian points where the start time and the end time of an event are stored as the x and y axes of the Cartesian coordinate thus enabling spatial queries on graph data. Our model improves the retrieval of temporal data using an existing graph database system without extending with additional operators. We present how queries based on Allen’s interval relationships can be represented using our model on a Cartesian coordinate system by visualizing these queries. Temporal queries based on temporal intervals are then used to validate our model and compare with the traditional way of storing temporal intervals (i.e., as attributes of nodes). Our experimental results on a soccer graph database with around 4, 000 games show that the spatial representation of temporal interval can provide significant performance (up to 3.5 times speedup) gains compared to a traditional model.
Graph Neural Networks (GNNs) have gained significant traction in deep multi-task learning (MTL) due to their superior expressive power. The Hierarchical Graph Neural Network (HGNN) enhances multi-task feature learning by constructing task-specific GNNs and class-specific GNNs to model inter-task and inter-class relationships. However, the graph structure of HGNN relies on initial features and fixed label similarities, which inadequately captures the evolving relationships within the data during training, ultimately constraining the classification performance. This limitation fails to capture the dynamic relationships within the data, ultimately restricting the model’s classification performance. To address this, we propose CC-HGNN, a novel multi-task learning framework that synergizes GNNs with contrastive learning. First, CC-HGNN introduces a cross-task supervised contrastive learning mechanism to refine node embeddings by pulling intra-class samples closer and pushing inter-class samples apart in the feature space. This process optimizes the discriminative power of node representations. Second, the optimized sample embeddings are aggregated to obtain task-level and class-level node representations; an attention mechanism then performs weighted message passing to further enhance the embeddings. The CC-HGNN is highly generalizable and can be integrated into various deep multi-task architectures. To validate the effectiveness of CC-HGNN, we conducted extensive experiments on three benchmark datasets: ImageCLEF, Office-Caltech-10, and Office-Home. The results demonstrate that CC-HGNN consistently outperforms existing methods, achieving superior classification accuracy. Additionally, visualization analyses reveal that CC-HGNN achieves clearer cluster separation in the feature space.
With the proliferation of cloud computing and distributed systems, efficient data indexing has become a cornerstone of large-scale data processing. While traditional index structures have long served as the backbone of database systems, they increasingly suffer from severe performance bottlenecks, including high lock contention and limited scalability—in modern high-concurrency environments. Consequently, the “Learned Index” paradigm has emerged as a transformative solution, leveraging machine learning models to approximate key distributions and accelerating query performance. However, despite their high lookup efficiency, existing learned indexes struggle to maintain stability in dynamic, large-scale scenarios: they typically rely on rigid array-based layouts that necessitate frequent, expensive model retraining or blocking structural adjustments to accommodate data drifts, and crucially, they lack native mechanisms to verify data integrity, thereby introducing prohibitive maintenance overheads and trust risks that compromise their viability in real-time, trusted cloud systems. To address these challenges in concurrent and distributed scenarios, this paper proposes FineStore-SL, an enhanced learning index designed to improve the performance and stability of cloud databases. FineStore-SL is built upon the FineStore architecture, optimizing it by replacing its original level-bin structure with a Skip List data structure, which utilizes multi-level indexing and randomized hierarchical levels to improve data processing efficiency. In addition, FineStore-SL incorporates a hash-based verification mechanism for consistency checks, ensuring data integrity while maintaining robustness against dynamic changes in distributed cloud environments. Extensive experiments demonstrate that FineStore-SL significantly outperforms state-of-the-art baselines in high-concurrency and dynamic scenarios, achieving nearly 2× higher throughput than the best-performing concurrent learned index in complex maintenance operations such as updates and deletions. Furthermore, the introduction of the hash-based verification mechanism incurs a negligible overhead of less than 2
The primary goal of database security is to establish data ownership by identifying the original creator of the data. It is especially crucial when it comes to electronic data since those sets are frequently altered and duplicated without giving due credit or acknowledgment to the original data source. Nowadays, to protect the database, watermarking systems are developed. Even though protecting relational databases using a watermarking system is challenging. Therefore, in this paper, an efficient watermarking system is developed to protect the relational database from data loss. The suggested system involves three phases such as optimal position selection, embedding, and extraction. Here, at first, for embedding, the optimal position of the relational database is selected using the Osprey with BAT optimization (OBO) algorithm. The proposed OBO algorithm is a combination of osprey optimization (O2) and the BAT algorithm. After position selection, we embed the watermark bit into the database. Then, the extraction process is carried out. Here, we used different embedding and extraction strategies for both numerical and non-numerical data. The efficiency of an introduced watermarking system is analyzed based on Mean square error (MSE) and Normalized correlation (NC). The experimental results show that the proposed watermarking system attained better results compared to other methods.
We give new results for the problem of approximating the number of triangles in graph streams, focusing on space-efficient algorithms that receive the input graph as a sequence of edges in arbitrary order. Our main contributions are: a) A two-pass algorithm that uses Õ( m^3/2/T) space. b) A one-pass algorithm that uses Õ( m^4/3/T^2/3) expected space and has access to a degree oracle. Our first result completes the picture for multi-pass triangle counting algorithms and it gives affirmative answer to an open question in Fichtenberger and Peng (PODS 2022) for the case of triangles where they asked if such a space bound is possible in two passes. It also matches the known lower bound of Ω( m^3/2/T) for the regime T= Ω (m) , thereby resolving the space complexity for this setting. Our second result establishes, for the first time, that access to a degree oracle can yield asymptotic improvements in the space complexity of one-pass algorithms. Specifically, for graphs with bounded arboricity b, our algorithm attains a space complexity of Õ( m√(b)/√(T)) . Notably, in the absence of a degree oracle, existing lower bounds preclude the existence of one-pass, sublinear-space algorithms even for planar graphs. To complement this result, we show that any one-pass algorithm—even with degree oracle access—requires Ω( n√(b)/√(T)) space, matching our upper bound for constant-arboricity graphs. In contrast, for dense graphs with m = Ω (n^2) and T = Θ (n) , we show that no sublinear space algorithm is possible even when allowed to query a degree oracle.
Many consensus protocols are evaluated using key-value (KV) workloads solely involving read/write operations. Weaker primitives, such as shared registers, can also process these workloads to ensure linearizable access to each key. However, a thorough performance evaluation comparing these two methodologies is still missing, leaving the question open as to which strategy is more effective for managing KV workloads under varying conditions. In this paper, we compare the shared register protocol ABD and consensus protocol EPaxos, which have similar quorum sizes and communication rounds for coordinating client requests. Our evaluation exposes two seldom-discussed shortcomings of consensus protocols, in contrast to shared-register protocols, when managing KV workloads: coarse-grained processing and the immediate sub-effects of write operations. These weaknesses significantly increase the coordination cost of consensus protocols in high-throughput scenarios. On the other hand, ABD consistently requires two rounds of communication for write operations, putting it at a disadvantage when handling write-heavy workloads compared to EPaxos. To tackle this issue, we propose WABD, the watermark-optimized ABD algorithm. WABD leverages loosely synchronized clocks to eliminate one round of communication for coordinating write operations. However, read operations still require two rounds of communication in the worst case, leading to high communication overhead and limited throughput under high client load. To address this, WABD introduces a coordination-free read path that minimizes coordination in high client load scenarios. Our evaluation shows that WABD achieves up to 40 times the throughput of EPaxos and 1.6 times the throughput of ABD, while maintaining similar latency levels to ABD under low client loads.
The widespread utilization of cloud services has increased the challenges, primarily in resource efficiency and timely task execution. The conventional methods often struggle to handle multi-objective constraints such as energy consumption, latency, and resource utilization in terms of heterogeneous loads, low response times, suboptimal load distributions, as well as Virtual Machine (VM) failures. To overcome these limitations, hybrid optimization techniques are introduced to achieve balanced, adaptive, and efficient scheduling across dynamic and heterogeneous cloud infrastructures. In order to allocate positions on all tasks and their scheduled tasks efficiently and reliably, the present research proposes the Haliaetus Rapid Position Allocation-based Load Balancing and Task Scheduling (HsRPA-LBTS) scheme. The suggested HsRPA algorithm integrates the strengths of the Osprey, Red Kite, and Bald Eagle optimizers that are hybridized and dynamically respond to workload variations with the consideration of energy constraints. A multi-objective fitness function further improves memory-aware task assignment, optimizing resource utilization, processing time, and overall system efficiency. During performance evaluation, the HsRPA-LBTS achieves a higher throughput ratio of 0.915 and an average resource utilization ratio of 0.799, with a lower degree of imbalance 0.07, and a makespan of 37.43s in the presence of 50 VMs for executing 1000 loads under a simulation environment.
Skyline queries are one of the most widely adopted tools for Multi-Criteria Analysis, with applications covering diverse domains, including, e.g., Database Systems, Data Mining, and Decision Making. Skylines indeed offer a useful overview of the most suitable alternatives in a dataset, while discarding all the options that are dominated by (i.e., worse than) others. The intrinsically quadratic complexity associated with skyline computation has pushed researchers to identify strategies for parallelizing the task, particularly by partitioning the dataset at hand. In this paper, after reviewing the main partitioning approaches available in the relevant literature, we propose two orthogonal optimization strategies for reducing the computational overhead, and compare them experimentally in a multi-core environment equipped with PySpark.
Temporal information plays a crucial role in many database applications, however support for queries on such data is limited. We present an index structure, termed RD-index, to support range-duration queries over interval timestamped relations, which constrain both the range of the tuples’ positions on the timeline and their duration. RD-index is a grid structure in the two-dimensional space, representing the position on the timeline and the duration of timestamps, respectively. Instead of using a regular grid, we consider the data distribution for the construction of the grid in order to ensure that each grid cell contains approximately the same number of intervals. RD-index features provable bounds on the running time of all the operations, allow for a simple implementation, and supports very predictable query performance. We benchmark our solution on a variety of datasets and query workloads, investigating both the query rate and the behavior of the individual queries. The results show that RD-index performs better than the baselines on range-duration queries, for which it is explicitly designed. Furthermore, it outperforms state of the art indexes also on mixed workloads containing queries that constrain either only the duration or the range along with range-duration queries. Finally, the size of the RD-index is in all settings smaller than the competitors.
The rapid growth of large-scale machine learning (ML) models has led numerous commercial companies to utilize ML models for generating predictive results to help business decision-making. As two primary components in traditional predictive pipelines, data processing, and model predictions often operate in separate execution environments, leading to redundant engineering and computations. Additionally, the diverging mathematical foundations of data processing and machine learning hinder cross-optimizations by combining these two components, thereby overlooking potential opportunities to expedite predictive pipelines. In this paper, we propose an operator fusing method based on GPU-accelerated linear algebraic evaluation of relational queries. Our method leverages linear algebra computation properties to merge operators in machine learning predictions and data processing, significantly accelerating predictive pipelines by up to 317x. We perform a complexity analysis to deliver quantitative insights into the advantages of operator fusion, considering various data and model dimensions. Furthermore, we extensively evaluate matrix multiplication query processing utilizing the widely-used Star Schema Benchmark. Through comprehensive evaluations, we demonstrate the effectiveness and potential of our approach in improving the efficiency of data processing and machine learning workloads on modern hardware.
Maps provide various sources of information. An important example of such information is textual labels such as cities, neighborhoods, and street names. Although we treat this information as facts, and despite the massive effort done by providers to continuously improve their accuracy, this data is far from perfect. Discrepancies in textual labels rendered on the map are one of the major sources of inconsistencies across map providers. These discrepancies can have significant impacts on the reliability of the derived information and decision-making processes. Thus, it is important to validate the accuracy and consistency in such data. Most providers treat this data as their propriety data and it is not available to the public, thus we cannot compare the data directly. To address these challenges, we introduce a novel computer vision-based approach for automatically extracting and classifying labels based on the visual characteristics of the label, which indicates its category based on the format convention used by the specific map provider. Based on the extracted data, we detect the degree of discrepancies across map providers. We consider three map providers: Bing Maps, Google Maps, and OpenStreetMaps. The neural network we develop classifies the text labels with an accuracy up to 93% in all providers. We leverage our system to analyze randomly selected regions in different markets. The studied markets are USA, Germany, France, and Brazil. Experimental results and statistical analysis reveal the amount of discrepancies across map providers per region. We calculate the Jaccard distance between the extracted text sets for each pair of map providers, which represents the discrepancy percentage. Discrepancies percentages as high as 90% were found in some markets.
Validating and debugging machine learning models is done by testing them on unseen data. During this process, analyzing model performance on various subsets of the test dataset is critical for fairness, trust, bias detection and explainability. We describe a new way to do this. Our solution, InfoMoD, applies recent work in information-theoretic data summarization to model diagnostics. To improve performance, we implemented InfoMoD in a distributed fashion, using Apache Spark. Based on four use cases ranging from finance to computer vision and hate speech detection, we show that InfoMoD concisely describes how a model performs across different subsets of the data and produces expected performance indicators for individual test instances.
In a rapidly evolving landscape, Personal Data Management Systems (PDMSs) provide individuals with the necessary tools to collect, manage and share their personal data. At the same time, the emergence of Trusted Execution Environments (TEEs) offers a way to address the critical challenge of securing user data while fostering a thriving ecosystem of data-driven applications. In this paper, we employ a PDMS architecture leveraging TEEs as a fundamental security foundation. Unlike conventional approaches, our architecture enables extensible data processing by integrating user-defined functions (UDFs), even from untrusted sources. Our focus is on UDFs involving potentially large sets of personal database objects, with a novel proposal to mitigate the potential risk of data leakage. We introduce security building blocks to impose an upper bound on data leakage and investigate the efficiency of several execution strategies considering different scenarios relevant to personal data management. We validate the proposed solutions through an implementation using Intel SGX on real datasets, demonstrating its effectiveness in achieving secure and efficient computations in diverse environments.
Hierarchical count histograms involve the publication of count statistics at various granularities based on a predefined hierarchy within a dimension table in a data warehouse. This task finds extensive applications in on-line analytical processing (OLAP) scenarios. This paper focuses on the rigorous privacy-preserving constraint when dealing with an untrusted server. We conduct a systematic investigation of this task and uncover the limitations of the straightforward baseline approach using local differential privacy, as it fails to strike an optimal balance between privacy and utility. We are thus motivated to propose DP-HORUS, a novel crypto-assisted Differentially Private framework for Hierarchical cOunt histogRams under Untrusted Server. DP-HORUS consists of a series of novel designs, including (1) Encrypted hierarchical tree (EHT) structure, which maintains the concept hierarchy in the input data; (2) Random matrix (RM), which reduces communication and computational cost; (3) To further boosted the utility, we propose DP-HORUS+ encompassing two additional modules of histograms structure (HS) and hierarchical consistency (HC), which are respectively introduced to reduce the noise caused by data sparsity and to ensure the hierarchy consistency; (4) To further boost the robust performance, we propose a series of schemes for workload queries based on DP-HORUS. We provide both theoretical analysis and extensive empirical study on both real-world and synthetic datasets, which demonstrates the superior utility of the proposed methods over the state-of-the-art solutions while ensuring strict privacy guarantee.
To improve the data security and integrity of the outsourced data, storing multiple copies of data on multiple cloud servers is a good way. Many public Provable Data Possession (PDP) schemes in multiple cloud servers have been proposed in recent years. However, in some scenarios, the Data Owner (DO) may not want anyone (e.g. a stranger) to check the integrity of their data. Nevertheless, few schemes consider the fault’s location function when the data auditing fails. Another problem is that anyone can make a challenge for the Cloud Server (CS) in the PDP schemes. Some access control strategies are necessary to reduce the waste of computation power resources of the CS. To solve these problems, we propose a certificateless and designed-verifier auditing scheme in multi-cloud storage environments. In our scheme, we utilize certificateless signature combined with a delegation key to achieve designed-verifier auditing. We design a secret Merkle Hash Tree (MHT) to locate the faults of CSs and data blocks. We utilize Zero-Knowledge Proof (ZKP) to achieve access control. Theoretical and experimental evaluation show that the proposed scheme is efficient and practical.
Focusing on the applicative setting represented by advanced big data analytics tools over data Cloud infrastructures, this paper introduces and theoretically proofs an innovative privacy-preserving OLAP framework against big query-workloads. The described applicative setting is common for big data analytics tools developed on top of commodity hardware solutions, where, rather than the execution of singleton big data queries, these queries are embedded into big data query programs, such that every elementary query evaluation step refers to one or more queries of the target query-workload. We complete our analytical and theoretical contributions by providing and experimentally assessing an innovative optimized approximate query answering algorithm for providing privacy-preserving approximate answers to OLAP queries.
Recently, the research community focuses on processing various types of location-based queries (or LBQs for short) (e.g., the range and nearest neighbor queries) on spatial objects of the same type in road networks, in which the road distance from objects to the query object is an important metric for determining the query result and needs to be calculated based on the connectivity of the network. The LBQs can be used to find the spatial objects with better spatial closeness (i.e., the shorter road distance to the query object). In many applications, information about the neighboring relationship between different types of objects may be more attractive to the user. As such, the location-based aggregate queries (or LBAggQs for short) are proposed, which consider not only the spatial closeness of objects but also the neighboring relationship between objects. However, the processing techniques for the LBAggQs are mainly based on a centralized paradigm, and hence suffer from highly dynamic environments where a large number of LBAggQs is issued concurrently. In this paper, a distributed processing technique, based on the MapReduce platform, is developed to answer multiple LBAggQs. Three tables T^dist_o,o , T^dist_o,p , and T^dist_p,p are first used to maintain information of the road distances between objects, and then evenly partitioned by a grid structure. With the three tables, a MapReduce-based algorithm, called the MRSAggDQ algorithm, is designed for query processing in a distributed manner. Finally, an extensive set of experiments using two real road networks is conducted to measure the average running time for different numbers of LBAggQs to be processed concurrently. The experimental results demonstrate the efficiency and the scalability of the proposed methods.
The Internet of Things (IoT) revolution has introduced sensor-rich devices to an ever growing landscape of smart environments. A key component in the IoT scenarios of the future is the requirement to utilize a shared database that allows all participants to operate collaboratively, transparently, immutably, correctly and with performance guarantees. Blockchain databases have been proposed by the community to alleviate these challenges, however existing blockchain architectures suffer from performance issues. In this paper we introduce Triabase, a novel permissioned blockchain system architecture that applies data decaying concepts to cope with scalability issues in regards to blockchain consensus and storage efficiency. For blockchain consensus, we propose the Proof of Federated Learning (PoFL) algorithm which exploits data decaying models as Proof-of-Work. For storage efficiency, we exploit federated learning to construct data postdiction machine learning models to minimize the storage of bulky data on the blockchain. We present a detailed explanation of our system architecture as well as the implementation in the Hyperledger fabric framework. We use our implementation to carry out an experimental evaluation with telco big data at scale showing that our framework exposes desirable qualities, namely efficient consensus at the blockchain layer while optimizing storage efficiency.
In the pursuit of graph processing performance, graph partitioning, as a crucial preprocessing step, has been widely concerned. Based on an in-depth analysis of Neighbor Expansion (NE) graph partitioning algorithm, we propose Parallel Expansion based on Clustering Coefficient (PECC). Firstly, to address the partition disturbance caused by internal structural changes during the process of vertex neighborhood expansion in the traditional NE algorithm, we perform a formal redefinition of the vertex state during the partitioning process and introduce the concept of clustering coefficient. Then, PECC uses the clustering coefficient as a metric to measure the closeness between vertices and potential partitions. Based on this metric, a novel parallel partitioning strategy in the distributed environment is proposed. This strategy consists of two core steps: the expansion process and the allocation process. Through two steps, PECC can effectively improve the operating efficiency of programs and significantly reduce the partitioning time. In addition, to ensure data consistency during parallel expansion, we adopt a distributed locking engine to solve concurrency management problems. Our evaluations on large real-world graphs show that in many cases, PECC achieves a balance between partitioning quality and computational efficiency. Finally, we show that PECC integrated on GraphX outperforms the built-in native algorithms.
Real-time multi-criteria decision-making applications in fields like high-speed algorithmic trading, emergency response, and disaster management have driven the development of new types of preference queries. This is an example of a skyline search. Multi-criteria decision-making utilizes the skyline operator to extract highly significant tuples or useful data points from extensive sets of multi-dimensional databases. The user’s settings determine the results, which include all tuples whose attribute vector remains undefeated by another tuple. The extracted tuples are commonly known as the skyline set. Lately, there has been a growing trend in research studies to perform skyline queries on data stream applications. These queries consist of extracting desired records from sliding windows and removing outdated records from incoming data sets that do not meet user requirements. The datasets in these applications are extremely large and exhibit a wide range of dimensions that vary over time. Consequently, the skyline query is considered a computationally demanding task, with the challenge of achieving a real-time response within an acceptable duration. We must transport and process enormous quantities of data. Traditional skyline algorithms have faced new challenges due to limitations in data transmission bandwidth and latency. The transfer of vast quantities of data would affect performance, power efficiency, and reliability. Consequently, it is imperative to make alterations to the computer paradigm. Parallel skyline queries have attracted the attention of both scholars and the business sector. The study of skyline queries has focused on sequential algorithms and parallel implementations for multicore processors, primarily due to their widespread use. While previous research has focused on sequential algorithms, there is a limitation to comprehensive studies that specifically address modern parallel processors. While numerous articles have been published regarding the parallelization of regular skyline queries, there is a limited amount of research dedicated specifically to the parallel processing of continuous skyline queries. This study introduces PRSS, a continuous skyline technique for multicore processors specifically designed for sliding window-based data streams. The efficacy of the proposed parallel implementation is demonstrated through tests conducted on both real-world and synthetic datasets, encompassing various point distributions, arrival rates, and window widths. The experimental results for a dataset characterized by a large number of dimensions and cardinality demonstrate significant acceleration.
