text:
Q||E|).A thorough experimentation on a large variety of real-world graphs confirms that our method returns smaller and denser solutions than other methods, and does so by adding to the query set Q a small number of ``important'' vertices (i.e., vertices with high centrality).},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1587–1602},
numpages = {16},
keywords = {graph mining, network design, approximation algorithms, wiener index},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2749448,
author = {Basu Roy, Senjuti and Lakshmanan, Laks V.S. and Liu, Rui},
title = {From Group Recommendations to Group Formation},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2749448},
doi = {10.1145/2723372.2749448},
abstract = {There has been significant recent interest in the area of group recommendations, where, given groups of users of a recommender system, one wants to recommend top-$k$ items to a group that maximize the satisfaction of the group members, according to a chosen semantics of group satisfaction. Examples semantics of satisfaction of a recommended itemset to a group include the so-called least misery (LM) and aggregate voting (AV). We consider the complementary problem of how to form groups such that the users in the formed groups are most satisfied with the suggested top-k recommendations. We assume that the recommendations will be generated according to one of the two group recommendation semantics -- LM or AV. Rather than assuming groups are given, or rely on ad hoc group formation dynamics, our framework allows a strategic approach for forming groups of users in order to maximize satisfaction. We show that the problem is NP-hard to solve optimally under both semantics. Furthermore, we develop two efficient algorithms for group formation under LM and show that they achieve bounded absolute error. We develop efficient heuristic algorithms for group formation under AV. We validate our results and demonstrate the scalability and effectiveness of our group formation algorithms on two large real data sets.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1603–1616},
numpages = {14},
keywords = {algorithm design, group recommendations, optimization methods},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2749450,
author = {Armenatzoglou, Nikos and Pham, Huy and Ntranos, Vasilis and Papadias, Dimitris and Shahabi, Cyrus},
title = {Real-Time Multi-Criteria Social Graph Partitioning: A Game Theoretic Approach},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2749450},
doi = {10.1145/2723372.2749450},
abstract = {Graph partitioning has attracted considerable attention due to its high practicality for real-world applications. It is particularly relevant to social networks because it enables the grouping of users into communities for market analysis and advertising purposes. In this paper, we introduce RMGP, a type of real-time multi-criteria graph partitioning for social networks that groups the users based on their connectivity and their similarity to a set of input classes. We consider RMGP as an on-line task, which may be frequently performed for different query parameters (e.g., classes). In order to overcome the serious performance issues associated with the large social graphs found in practice, we develop solutions based on a game theoretic framework. Specifically, we consider each user as a player, whose goal is to find the class that optimizes his objective function. We propose algorithms based on best-response dynamics, analyze their properties, and show their efficiency and effectiveness on real datasets under centralized and decentralized scenarios.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1617–1628},
numpages = {12},
keywords = {social networks, game theory, graph partitioning},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2749446,
author = {She, Jieying and Tong, Yongxin and Chen, Lei},
title = {Utility-Aware Social Event-Participant Planning},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2749446},
doi = {10.1145/2723372.2749446},
abstract = {Online event-based social network (EBSN) platforms are becoming popular these days. An important task of managing EBSNs is to arrange proper social events to interested users. Existing approaches usually assume that each user only attends one event or ignore location information. The overall utility of such strategy is limited in real world: 1) each user may attend multiple events; 2) attending multiple events will incur spatio-temporal conflicts and travel expenses. Thus, a more intelligent EBSN platform that provides personalized event planning for each participant is desired. In this paper, we first formally define the problem of Utility-aware Social Event-participant Planning (USEP), which is proven to be NP-hard. To solve the USEP problem, we first devise a greedy-based heuristic algorithm, which performs fast under certain circumstances but has no approximation guarantee. We then present a two-step approximation framework, which not only guarantees a 1/2-approximation ratio but also includes a series of optimization techniques to improve its space/time efficiency. Finally, we verify the efficiency and effectiveness of the proposed methods through extensive experiments on real and synthetic datasets.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1629–1643},
numpages = {15},
keywords = {event planning, event-based social network},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2749444,
author = {Zhou, Xiangmin and Chen, Lei and Zhang, Yanchun and Cao, Longbing and Huang, Guangyan and Wang, Chen},
title = {Online Video Recommendation in Sharing Community},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2749444},
doi = {10.1145/2723372.2749444},
abstract = {The creation of sharing communities has resulted in the astonishing increasing of digital videos, and their wide applications in the domains such as entertainment, online news broadcasting etc. The improvement of these applications relies on effective solutions for social user access to video data. This fact has driven the recent research interest in social recommendation in shared communities. Although certain effort has been put into video recommendation in shared communities, the contextual information on social users has not been well exploited for effective recommendation. In this paper, we propose an approach based on the content and social information of videos for the recommendation in sharing communities. Specifically, we first exploit a robust video cuboid signature together with the Earth Mover's Distance to capture the content relevance of videos. Then, we propose to identify the social relevance of clips using the set of users belonging to a video. We fuse the content relevance and social relevance to identify the relevant videos for recommendation. Following that, we propose a novel scheme called sub-community-based approximation together with a hash-based optimization for improving the efficiency of our solution. Finally, we propose an algorithm for efficiently maintaining the social updates in dynamic shared communities. The extensive experiments are conducted to prove the high effectiveness and efficiency of our proposed video recommendation approach.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1645–1656},
numpages = {12},
keywords = {social relevance, online video recommendation},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2742789,
author = {Prasad, Shreya and Fard, Arash and Gupta, Vishrut and Martinez, Jorge and LeFevre, Jeff and Xu, Vincent and Hsu, Meichun and Roy, Indrajit},
title = {Large-Scale Predictive Analytics in Vertica: Fast Data Transfer, Distributed Model Creation, and In-Database Prediction},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2742789},
doi = {10.1145/2723372.2742789},
abstract = {A typical predictive analytics workflow will pre-process data in a database, transfer the resulting data to an external statistical tool such as R, create machine learning models in R, and then apply the model on newly arriving data. Today, this workflow is slow and cumbersome. Extracting data from databases, using ODBC connectors, can take hours on multi-gigabyte datasets. Building models on single-threaded R does not scale. Finally, it is nearly impossible to use R or other common tools, to apply models on terabytes of newly arriving data.We solve all the above challenges by integrating HP Vertica with Distributed R, a distributed framework for R. This paper presents the design of a high performance data transfer mechanism, new data-structures in Distributed R to maintain data locality with database table segments, and extensions to Vertica for saving and deploying R models. Our experiments show that data transfers from Vertica are 6x faster than using ODBC connections. Even complex predictive analysis on 100s of gigabytes of database tables can complete in minutes, and is as fast as in-memory systems like Spark running directly on a distributed file system.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1657–1668},
numpages = {12},
keywords = {r, in-database, machine learning, hp vertica},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2742791,
author = {Tran, Quoc Trung and Morfonios, Konstantinos and Polyzotis, Neoklis},
title = {Oracle Workload Intelligence},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2742791},
doi = {10.1145/2723372.2742791},
abstract = {Analyzing and understanding the characteristics of the incoming workload is crucial in unraveling trends and tuning the performance of a database system. In this work, we present Oracle Workload Intelligence (WI), a tool for workload modeling and mining, as our attempt to infer the processes that generate a given workload. WI consists of two main functionalities. First, WI derives a model that captures the main characteristics of the workload without overfitting, which makes it likely to generalize well to unseen instances of the workload. Such a model provides insights into the most frequent code paths in the application that drives the workload, and also enables optimizations inside the database system that target sequences of query statements. Second, WI can compare the models of different snapshots of the workload to detect whether the workload has changed. Such changes might indicate new trends, regressions, problems, or even security issues. We demonstrate the effectiveness of WI with an experimental study on synthetic workloads and customer-provided application benchmarks.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1669–1681},
numpages = {13},
keywords = {workload modeling, significant pattern, workload intelligence},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2742798,
author = {Colgrove, John and Davis, John D. and Hayes, John and Miller, Ethan L. and Sandvig, Cary and Sears, Russell and Tamches, Ari and Vachharajani, Neil and Wang, Feng},
title = {Purity: Building Fast, Highly-Available Enterprise Flash Storage from Commodity Components},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2742798},
doi = {10.1145/2723372.2742798},
abstract = {Although flash storage has largely replaced hard disks in consumer class devices, enterprise workloads pose unique challenges that have slowed adoption of flash in ``performance tier'' storage appliances. In this paper, we describe Purity, the foundation of Pure Storage's Flash Arrays, the first all-flash enterprise storage system to support compression, deduplication, and high-availability.Purity borrows techniques from modern database and key-value storage architectures, and introduces novel storage primitives that have wide applicability to data management systems. For instance, all writes in Purity are monotonic, and deletions are handled using an atomic predicate-based tuple elision primitive.Purity's redundancy mechanisms are optimized for SSD failure modes and performance characteristics, allowing for fast recovery from component failures and lower space overhead than the best hard disk systems. We built deduplication and data compression schemes atop these primitives.Flash changes storage capacity/performance tradeoffs: unlike disk-based systems, flash deployments are rarely performance bound. A single Purity appliance can provide over 7GiB/s of throughput on 32KiB random I/Os, even through multiple device failures, and while providing asynchronous off-site replication. Typical installations have 99.9% latencies under 1ms, and production arrays average 5.4x data reduction and 99.999% availability.Purity takes advantage of storage performance increasing more rapidly than computational performance to build a simpler (with respect to engineering, installation, and management) scale-up storage appliance that supports hundreds of terabytes of highly-available, high-performance storage. The resulting performance and capacity supports many customer deployments of multiple applications, including scale-out and parallel systems, such as MongoDB and Oracle RAC, on a single Purity appliance.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1683–1694},
numpages = {12},
keywords = {log structured storage, enterprise flash storage, high availability, storage area networks, scale up architectures, deduplication},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2742799,
author = {Terlecki, Pawel and Xu, Fei and Shaw, Marianne and Kim, Valeri and Wesley, Richard},
title = {On Improving User Response Times in Tableau},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2742799},
doi = {10.1145/2723372.2742799},
abstract = {The rapid increase in data volumes and complexity of applied analytical tasks poses a big challenge for visualization solutions. It is important to keep the experience highly interactive, so that users stay engaged and can perform insightful data exploration. Query processing usually dominates the cost of visualization generation. Therefore, in order to achieve acceptable response times, one needs to utilize backend capabilities to the fullest and apply techniques, such as caching or prefetching. In this paper we discuss key data processing components in Tableau: the query processor, query caches, Tableau Data Engine [1, 2] and Data Server. Furthermore, we cover recent performance improvements related to the number and quality of remote queries, broader reuse of cached data, and application of inter and intra query parallelism.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1695–1706},
numpages = {12},
keywords = {column store, data visualization, query batching, data server, tableau data engine, concurrency},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2731082,
author = {Viglas, Stratis D.},
title = {Data Management in Non-Volatile Memory},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2731082},
doi = {10.1145/2723372.2731082},
abstract = {Non-volatile memory promises to bridge the gap between main memory and secondary storage by offering a universal storage device. Its performance profile is unique in that its latency is close to main memory and it is byte addressable, but it exhibits asymmetric I/O in that writes are more expensive than reads. These properties imply that it cannot act as a drop-in replacement for either main-memory or disk. Therefore, we must revisit the salient aspects of data management in light of this new technology. In what follows we present the current work in the area with a view towards identifying the open problems and exposing the research opportunities. In particular, we address issues like: (a) incorporating non-volatile memory into the data management stack, (b) supporting transactions and ensuring persistence and recovery, and (c) query processing.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1707–1711},
numpages = {5},
keywords = {recovery, persistence, query processing, non-volatile memory, performance},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2723725,
author = {Chu, Xu and He, Yeye and Chakrabarti, Kaushik and Ganjam, Kris},
title = {TEGRA: Table Extraction by Global Record Alignment},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2723725},
doi = {10.1145/2723372.2723725},
abstract = {It is well known today that pages on the Web contain a large number of content-rich relational tables. Such tables have been systematically extracted in a number of efforts to empower important applications such as table search and schema discovery. However, a significant fraction of relational tables are not embedded in the standard HTML table tags, and are thus difficult to extract. In particular, a large number of relational tables are known to be in a ``list'' form, which contains a list of clearly separated rows that are not separated into columns.In this work, we address the important problem of automatically extracting multi-column relational tables from such lists. Our key intuition lies in the simple observation that in correctly-extracted tables, values in the same column are coherent, both at a syntactic and at a semantic level. Using a background corpus of over 100 million tables crawled from the Web, we quantify semantic coherence based on a statistical measure of value co-occurrence in the same column from the corpus. We then model table extraction as a principled optimization problem -- we allocate tokens in each row sequentially to a fixed number of columns, such that the sum of coherence across all pairs of values in the same column is maximized. Borrowing ideas from $A^star$ search and metric distance, we develop an efficient 2-approximation algorithm. We conduct large-scale table extraction experiments using both real Web data and proprietary enterprise spreadsheet data. Our approach considerably outperforms the state-of-the-art approaches in terms of quality, achieving over 90% F-measure across many cases.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1713–1728},
numpages = {16},
keywords = {table extraction, html lists, web tables, information extraction},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2751523,
author = {Liu, Jialu and Shang, Jingbo and Wang, Chi and Ren, Xiang and Han, Jiawei},
title = {Mining Quality Phrases from Massive Text Corpora},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2751523},
doi = {10.1145/2723372.2751523},
abstract = {Text data are ubiquitous and play an essential role in big data applications. However, text data are mostly unstructured. Transforming unstructured text into structured units (e.g., semantically meaningful phrases) will substantially reduce semantic ambiguity and enhance the power and efficiency at manipulating such data using database technology. Thus mining quality phrases is a critical research problem in the field of databases. In this paper, we propose a new framework that extracts quality phrases from text corpora integrated with phrasal segmentation. The framework requires only limited training but the quality of phrases so generated is close to human judgment. Moreover, the method is scalable: both computation time and required space grow linearly as corpus size increases. Our experiments on large text corpora demonstrate the quality and efficiency of the new method.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1729–1744},
numpages = {16},
keywords = {phrase mining, phrasal segmentation},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2750548,
author = {Trummer, Immanuel and Halevy, Alon and Lee, Hongrae and Sarawagi, Sunita and Gupta, Rahul},
title = {Mining Subjective Properties on the Web},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2750548},
doi = {10.1145/2723372.2750548},
abstract = {Even with the recent developments in Web search of answering queries from structured data, search engines are still limited to queries with an objective answer, such as EUROPEAN CAPITALS or WOODY ALLEN MOVIES. However, many queries are subjective, such as SAFE CITIES, or CUTE ANIMALS. The underlying knowledge bases of search engines do not contain answers to these queries because they do not have a ground truth. We describe the Surveyor system that mines the dominant opinion held by authors of Web content about whether a subjective property applies to a given entity. The evidence on which SURVEYOR relies is statements extracted from Web text that either support the property or claim its negation. The key challenge that SURVEYOR faces is that simply counting the number of positive and negative statements does not suffice, because there are multiple hidden biases with which content tends to be authored on the Web. SURVEYOR employs a probabilistic model of how content is authored on the Web. As one example, this model accounts for correlations between the subjective property and the frequency with which it is mentioned on the Web. The parameters of the model are specialized to each property and entity type.Surveyor was able to process a large Web snapshot within a few hours, resulting in opinions for over 4~billion entity-property combinations. We selected a subset of 500 entity-property combinations and compared our results to the dominant opinion of a large number of Amazon Mechanical Turk (AMT) workers. The predictions of Surveyor match the results from AMT in 77% of all cases (and 87% for test cases where inter-worker agreement is high), significantly outperforming competing approaches.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1745–1760},
numpages = {16},
keywords = {subjective properties, user behavior model, text mining},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2751522,
author = {Hua, Wen and Zheng, Kai and Zhou, Xiaofang},
title = {Microblog Entity Linking with Social Temporal Context},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2751522},
doi = {10.1145/2723372.2751522},
abstract = {Nowadays microblogging sites, such as Twitter and Chinese Sina Weibo, have established themselves as an invaluable information source, which provides a huge collection of manually-generated tweets with broad range of topics from daily life to breaking news. Entity linking is indispensable for understanding and maintaining such information, which in turn facilitates many real-world applications such as tweet clustering and classification, personalized microblog search, and so forth. However, tweets are short, informal and error-prone, rendering traditional approaches for entity linking in documents largely inapplicable. Recent work addresses this problem by utilising information from other tweets and linking entities in a batch manner. Nevertheless, the high computational complexity makes this approach infeasible for real-time applications given the high arrival rate of tweets. In this paper, we propose an efficient solution to link entities in tweets by analyzing their social and temporal context. Our proposed framework takes into consideration three features, namely entity popularity, entity recency, and user interest information embedded in social interactions to assist the entity linking task. Effective indexing structures along with incremental algorithms have also been developed to reduce the computation and maintenance costs of our approach. Experimental results based on real tweet datasets verify the effectiveness and efficiency of our proposals.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1761–1775},
numpages = {15},
keywords = {microblog entity linking, user interest, entity recency, social temporal context, entity popularity},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2723714,
author = {Papailiou, Nikolaos and Tsoumakos, Dimitrios and Karras, Panagiotis and Koziris, Nectarios},
title = {Graph-Aware, Workload-Adaptive SPARQL Query Caching},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2723714},
doi = {10.1145/2723372.2723714},
abstract = {The pace at which data is described, queried and exchanged using the RDF specification has been ever increasing with the proliferation of Semantic Web. Minimizing SPARQL query response times has been an open issue for the plethora of RDF stores, yet SPARQL result caching techniques have not been extensively utilized. In this work we present a novel system that addresses graph-based, workload-adaptive indexing of large RDF graphs by caching SPARQL query results. At the heart of the system lies a SPARQL query canonical labelling algorithm that is used to uniquely index and reference SPARQL query graphs as well as their isomorphic forms. We integrate our canonical labelling algorithm with a dynamic programming planner in order to generate the optimal join execution plan, examining the utilization of both primitive triple indexes and cached query results. By monitoring cache requests, our system is able to identify and cache SPARQL queries that, even if not explicitly issued, greatly reduce the average response time of a workload. The proposed cache is modular in design, allowing integration with different RDF stores. Incorporating it to an open-source, distributed RDF engine that handles large scale RDF datasets, we prove that workload-adaptive caching can reduce average response times by up to two orders of magnitude and offer interactive response times for complex workloads and huge RDF datasets.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1777–1792},
numpages = {16},
keywords = {rdf, caching, sparql, distributed databases, query planning, adaptive indexing},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2746483,
author = {Atre, Medha},
title = {<i>Left Bit Right</i>: For SPARQL Join Queries with OPTIONAL Patterns (Left-Outer-Joins)},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2746483},
doi = {10.1145/2723372.2746483},
abstract = {SPARQL basic graph pattern (BGP) (a.k.a. SQL inner-join) query optimization is a well researched area. However, optimization of OPTIONAL pattern queries (a.k.a. SQL left-outer-joins) poses additional challenges, due to the restrictions on the reordering of left-outer-joins. The occurrence of such queries tends to be as high as 50% of the total queries (e.g., DBPedia query logs).In this paper, we present Left Bit Right (LBR), a technique for well-designed nested BGP and OPTIONAL pattern queries. Through LBR, we propose a novel method to represent such queries using a graph of supernodes, which is used to aggressively prune the RDF triples, with the help of compressed indexes. We also propose novel optimization strategies -- first of a kind, to the best of our knowledge -- that combine together the characteristics of acyclicity of queries, minimality, and nullification, best-match operators. In this paper, we focus on OPTIONAL patterns without UNIONs or FILTERs, but we also show how UNIONs and FILTERs can be handled with our technique using a query rewrite. Our evaluation on RDF graphs of up to and over one billion triples, on a commodity laptop with 8 GB memory, shows that LBR can process well-designed low-selectivity complex queries up to 11 times faster compared to the state-of-the-art RDF column-stores as Virtuoso and MonetDB, and for highly selective queries, LBR is at par with them.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1793–1808},
numpages = {16},
keywords = {semi-joins, query optimization, sparql optional patterns, compressed bitvectors., left-outer-joins},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2747648,
author = {Zheng, Weiguo and Zou, Lei and Lian, Xiang and Yu, Jeffrey Xu and Song, Shaoxu and Zhao, Dongyan},
title = {How to Build Templates for RDF Question/Answering: An Uncertain Graph Similarity Join Approach},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2747648},
doi = {10.1145/2723372.2747648},
abstract = {A challenging task in the natural language question answering (Q/A for short) over RDF knowledge graph is how to bridge the gap between unstructured natural language questions (NLQ) and graph-structured RDF data (GOne of the effective tools is the "template", which is often used in many existing RDF Q/A systems. However, few of them study how to generate templates automatically. To the best of our knowledge, we are the first to propose a join approach for template generation. Given a workload D of SPARQL queries and a set N of natural language questions, the goal is to find some pairs q, n, for q∈ D ∧ n ∈, N, where SPARQL query q is the best match for natural language question n. These pairs provide promising hints for automatic template generation. Due to the ambiguity of the natural languages, we model the problem above as an uncertain graph join task. We propose several structural and probability pruning techniques to speed up joining. Extensive experiments over real RDF Q/A benchmark datasets confirm both the effectiveness and efficiency of our approach.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1809–1824},
numpages = {16},
keywords = {graph database, question answering, rdf},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2746479,
author = {Qiao, Shi and \"{O}zsoyo\u{g}lu, Z. Meral},
title = {RBench: Application-Specific RDF Benchmarking},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2746479},
doi = {10.1145/2723372.2746479},
abstract = {As more RDF data management systems and RDF data querying techniques emerge, RDF benchmarks providing a controllable and comparable testing environment for applications are needed. To address the needs of diverse applications, we propose an application-specific framework, called RBench, to generate RDF benchmarks. RBench takes an RDF dataset from any application as a template, and generates a set of synthetic datasets with similar characteristics including graph structure and literal labels, for the required "size scaling factor" and the "degree scaling factor". RBench analyzes several features from the given RDF dataset, and uses them to reconstruct the new benchmark graph. A flexible query load generation process is then proposed according to the design of RBench. Efficiency and usability of RBench are demonstrated via experimental results.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1825–1838},
numpages = {14},
keywords = {application-specific benchmarking},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2749428,
author = {El-Roby, Ahmed and Aboulnaga, Ashraf},
title = {ALEX: Automatic Link Exploration in Linked Data},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2749428},
doi = {10.1145/2723372.2749428},
abstract = {There has recently been an increase in the number of RDF knowledge bases published on the Internet. These rich RDF data sets can be useful in answering many queries, but much more interesting queries can be answered by integrating information from different data sets. This has given rise to research on automatically linking different RDF data sets representing different knowledge bases. This is challenging due to their scale and semantic heterogeneity. Various approaches have been proposed, but there is room for improving the quality of the generated links.In this paper, we present ALEX, a system that aims at improving the quality of links between RDF data sets by using feedback provided by users on the answers to linked data queries. ALEX starts with a set of candidate links obtained using any automatic linking algorithm. ALEX utilizes user feedback to discover new links that did not exist in the set of candidate links while preserving link precision. ALEX discovers these new links by finding links that are similar to a link approved by the user through feedback on queries. ALEX uses a Monte-Carlo reinforcement learning method to learn how to explore in the space of possible links around a given link. Our experiments on real-world data sets show that ALEX is efficient and significantly improves the quality of links.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1839–1853},
numpages = {15},
keywords = {reinforcement learning, rdf, linked data, knoweldge bases, federated query processing, automatic linking},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2737793,
author = {Paparrizos, John and Gravano, Luis},
title = {K-Shape: Efficient and Accurate Clustering of Time Series},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2737793},
doi = {10.1145/2723372.2737793},
abstract = {The proliferation and ubiquity of temporal data across many disciplines has generated substantial interest in the analysis and mining of time series. Clustering is one of the most popular data mining methods, not only due to its exploratory power, but also as a preprocessing step or subroutine for other techniques. In this paper, we present k-Shape, a novel algorithm for time-series clustering. k-Shape relies on a scalable iterative refinement procedure, which creates homogeneous and well-separated clusters. As its distance measure, k-Shape uses a normalized version of the cross-correlation measure in order to consider the shapes of time series while comparing them. Based on the properties of that distance measure, we develop a method to compute cluster centroids, which are used in every iteration to update the assignment of time series to clusters. To demonstrate the robustness of k-Shape, we perform an extensive experimental evaluation of our approach against partitional, hierarchical, and spectral clustering methods, with combinations of the most competitive distance measures. k-Shape outperforms all scalable approaches in terms of accuracy. Furthermore, k-Shape also outperforms all non-scalable (and hence impractical) combinations, with one exception that achieves similar accuracy results. However, unlike k-Shape, this combination requires tuning of its distance measure and is two orders of magnitude slower than k-Shape. Overall, k-Shape emerges as a domain-independent, highly accurate, and highly efficient clustering approach for time series with broad applications.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1855–1870},
numpages = {16},
keywords = {centroid computation, clustering, distance measure, time-series data},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2749429,
author = {Zhou, Jingbo and Tung, Anthony K.H.},
title = {SMiLer: A Semi-Lazy Time Series Prediction System for Sensors},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2749429},
doi = {10.1145/2723372.2749429},
abstract = {It is useful to predict future values in time series data, for example when there are many sensors monitoring environments such as urban space. The Gaussian Process (GP) model is considered as a promising technique for this setting. However, the GP model requires too high a training cost to be tractable for large data. Though approximation methods have been proposed to improve GP's scalability, they usually can only capture global trends in the data and fail to preserve small-scale patterns, resulting in unsatisfactory performance.We propose a new method to apply the GP for sensor time series prediction. Instead of (eagerly) training GPs on entire datasets, we custom-build query-dependent GPs on small fractions of the data for each prediction request.Implementing this idea in practice at scale requires us to overcome two obstacles. On the one hand, a central challenge with such a semi-lazy learning model is the substantial model-building effort at kNN query time, which could lead to unacceptable latency. We propose a novel two-level inverted-like index to support kNN search using the DTW on the GPU, making such "just-in-time" query-dependent model construction feasible for real-time applications.On the other hand, several parameters should be tuned for each time series individually since different sensors have different data generating processes in diverse environments. Manually configuring the parameters is usually not feasible due to the large number of sensors. To address this, we devise an adaptive auto-tuning mechanism to automatically determine and dynamically adjust the parameters for each time series with little human assistance.Our method has the following strong points: (a) it can make prediction in real time without a training phase; (b) it can yield superior prediction accuracy; and (c) it can effectively estimate the analytical predictive uncertainty.To illustrate our points, we present SMiLer, a semi-lazy time series prediction system for sensors. Extensive experiments on real-world datasets demonstrate its effectiveness and efficiency. In particular, by devising a two-level inverted-like index on the GPU with an enhanced lower bound of the DTW, SMiLer accelerates the efficiency of kNN search by one order of magnitude over its baselines. The prediction accuracy of SMiLer is better than the state-of-the-art competitors (up to 10 competitors) with better estimation of predictive uncertainty.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1871–1886},
numpages = {16},
keywords = {dtw, time series, sensors, gpu, semi-lazy learning, gaussian process, predictive analysis},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2723732,
author = {Sun, Wen and Fokoue, Achille and Srinivas, Kavitha and Kementsietsidis, Anastasios and Hu, Gang and Xie, Guotong},
title = {SQLGraph: An Efficient Relational-Based Property Graph Store},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2723732},
doi = {10.1145/2723372.2723732},
abstract = {We show that existing mature, relational optimizers can be exploited with a novel schema to give better performance for property graph storage and retrieval than popular noSQL graph stores. The schema combines relational storage for adjacency information with JSON storage for vertex and edge attributes. We demonstrate that this particular schema design has benefits compared to a purely relational or purely JSON solution. The query translation mechanism translates Gremlin queries with no side effects into SQL queries so that one can leverage relational query optimizers. We also conduct an empirical evaluation of our schema design and query translation mechanism with two existing popular property graph stores. We show that our system is 2-8 times better on query performance, and 10-30 times better in throughput on 4.3 billion edge graphs compared to existing stores.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1887–1901},
numpages = {15},
keywords = {gremlin, relational storage, property graphs},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2746482,
author = {Yuan, Dayu and Mitra, Prasenjit and Yu, Huiwen and Giles, C. Lee},
title = {Updating Graph Indices with a One-Pass Algorithm},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2746482},
doi = {10.1145/2723372.2746482},
abstract = {Indices are commonly built into graph databases in order to support fast searches. Any given graph database and the distribution of queries will change over time. Therefore, the cost of processing queries using a static graph index increases because the index is built to optimize old snapshots of the database. There is growing research interest in determining how to update a graph index with the purpose of adapting to database and query changes. Updating features in a graph index is typically an NP-hard problem. In addition, because the features are chosen from a large number of frequent subgraphs, a multi-pass algorithm is not scalable to big datasets. In order to address this issue, we propose a time-efficient one-pass algorithm that is designed to update a graph index by scanning each frequent subgraph at most once. The algorithm replaces a feature with a new subgraph if the latter is ``better" than the former one. We use the branch and bound technique to skip subgraphs that cannot outperform any of the features in the graph index. We further use a decomposed index and reduce the space complexity from O(|G||Q|) to O(|G| + |Q|), where G is database graphs and Q is a query workload. Through the empirical study, we show that the one-pass algorithm is 5--100 times faster than all previous algorithms for updating graph indices. In addition, the one-pass algorithm guarantees the return of a close to optimum solution. Our experiments show that when the one-pass algorithm is used to update an index, the query-processing speed is $1$--$2$ times faster than that of other cutting-edge indices, i.e., the FGindex and the gIndex.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1903–1916},
numpages = {14},
keywords = {graph database, graph mining},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2742795,
author = {Gupta, Anurag and Agarwal, Deepak and Tan, Derek and Kulesza, Jakub and Pathak, Rahul and Stefani, Stefano and Srinivasan, Vidhya},
title = {Amazon Redshift and the Case for Simpler Data Warehouses},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2742795},
doi = {10.1145/2723372.2742795},
abstract = {Amazon Redshift is a fast, fully managed, petabyte-scale data warehouse solution that makes it simple and cost-effective to efficiently analyze large volumes of data using existing business intelligence tools. Since launching in February 2013, it has been Amazon Web Service's (AWS) fastest growing service, with many thousands of customers and many petabytes of data under management. Amazon Redshift's pace of adoption has been a surprise to many participants in the data warehousing community. While Amazon Redshift was priced disruptively at launch, available for as little as $1000/TB/year, there are many open-source data warehousing technologies and many commercial data warehousing engines that provide free editions for development or under some usage limit. While Amazon Redshift provides a modern MPP, columnar, scale-out architecture, so too do many other data warehousing engines. And, while Amazon Redshift is available in the AWS cloud, one can build data warehouses using EC2 instances and the database engine of one's choice with either local or network-attached storage.In this paper, we discuss an oft-overlooked differentiating characteristic of Amazon Redshift -- simplicity. Our goal with Amazon Redshift was not to compete with other data warehousing engines, but to compete with non-consumption. We believe the vast majority of data is collected but not analyzed. We believe, while most database vendors target larger enterprises, there is little correlation in today's economy between data set size and company size. And, we believe the models used to procure and consume analytics technology need to support experimentation and evaluation. Amazon Redshift was designed to bring data warehousing to a mass market by making it easy to buy, easy to tune and easy to manage while also being fast and cost-effective.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1917–1923},
numpages = {7},
keywords = {columnar database:redshift:data warehousing:mpp, amazon redshift},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2742800,
author = {Deshpande, Mukund and Ray, Dhruva and Dixit, Sameer and Agasti, Avadhoot},
title = {ShareInsights: An Unified Approach to Full-Stack Data Processing},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2742800},
doi = {10.1145/2723372.2742800},
abstract = {The field of data analysis seeks to extract value from data for either business or scientific benefit. This field has seen a renewed interest with the advent of big data technologies and a new organizational role called data scientist. Even with the new found focus, the task of analyzing large amounts of data is still challenging and time-consuming.The essence of data analysis involves setting up data pipe-lines which consists of several operations that are chained together - starting from data collection, data quality checks, data integration, data analysis and data visualization (including the setting up of interaction paths in that visualization).In our opinion, the challenges stem from from the technology diversity at each stage of the data pipeline as well as the lack of process around the analysis.In this paper we present a platform that aims to significantly reduce the time it takes to build data pipelines. The platform attempts to achieve this in following ways. Allow the user to describe the entire data pipeline with a single language and idioms - all the way from data ingestion to insight expression (via visualization and end-user interaction).Provide a rich library of parts that allow users to quickly assemble a data analysis pipeline in the language.Allow for a collaboration model that allows multiple users to work together on a data analysis pipeline as well as leverage and extend prior work with minimal effort.We studied the efficacy of the platform for a data hackathon competition conducted in our organization. The hackathon provided us with a way to study the impact of the approach. Rich data pipelines which traditionally took weeks to build were constructed and deployed in hours. Consequently, we believe that the complexity of designing and running the data analysis pipeline can be significantly reduced; leading to a marked improvement in the productivity of data analysts/data scientists.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1925–1940},
numpages = {16},
keywords = {data pipeline, data analysis, data visualization, big data},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2746484,
author = {Trummer, Immanuel and Koch, Christoph},
title = {An Incremental Anytime Algorithm for Multi-Objective Query Optimization},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2746484},
doi = {10.1145/2723372.2746484},
abstract = {Query plans offer diverse tradeoffs between conflicting cost metrics such as execution time, energy consumption, or execution fees in a multi-objective scenario. It is convenient for users to choose the desired cost tradeoff in an interactive process, dynamically adding constraints and finally selecting the best plan based on a continuously refined visualization of optimal cost tradeoffs. Multi-objective query optimization (MOQO) algorithms must possess specific properties to support such an interactive process: First, they must be anytime algorithms, generating multiple result plan sets of increasing quality with low latency between consecutive results. Second, they must be incremental, meaning that they avoid regenerating query plans when being invoked several times for the same query but with slightly different user constraints. We present an incremental anytime algorithm for MOQO, analyze its complexity and show that it offers an attractive tradeoff between result update frequency, single invocation time complexity, and amortized time over multiple invocations. Those properties make it suitable to be used within an interactive query optimization process. We evaluate the algorithm in comparison with prior work on TPC-H queries; our implementation is based on the Postgres database management system.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1941–1953},
numpages = {13},
keywords = {multi-objective, anytime, query optimization, incremental},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2723736,
author = {Meneghetti, Niccolo' and Mindolin, Denis and Ciaccia, Paolo and Chomicki, Jan},
title = {Output-Sensitive Evaluation of Prioritized Skyline Queries},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2723736},
doi = {10.1145/2723372.2723736},
abstract = {Skylines assume that all attributes are equally important, as each dimension can always be traded off for another. Prioritized skylines (p-skylines) take into account non-compensatory preferences, where some dimensions are deemed more important than others, and trade-offs are constrained by the relative importance of the attributes involved.In this paper we show that querying using non-compensatory preferences is computationally efficient. We focus on preferences that are representable with p-expressions, and develop an efficient in-memory divide-and-conquer algorithm for answering p-skyline queries. Our algorithm is output-sensitive; this is very desirable in the context of preference queries, since the output is expected to be, on average, only a small fraction of the input. We prove that our method is well behaved in both the worst- and the average-case scenarios. Additionally, we develop a general framework for benchmarking p-skyline algorithms, showing how to sample prioritized preference relations uniformly, and how to highlight the effect of data correlation on performance. We conclude our study with extensive experimental results.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1955–1967},
numpages = {13},
keywords = {performance, preference, prioritized accumulation, algorithms, preference query, p-skyline, experimentation, skyline, pareto accumulation},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2723713,
author = {Kumar, Arun and Naughton, Jeffrey and Patel, Jignesh M.},
title = {Learning Generalized Linear Models Over Normalized Data},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2723713},
doi = {10.1145/2723372.2723713},
abstract = {Enterprise data analytics is a booming area in the data management industry. Many companies are racing to develop toolkits that closely integrate statistical and machine learning techniques with data management systems. Almost all such toolkits assume that the input to a learning algorithm is a single table. However, most relational datasets are not stored as single tables due to normalization. Thus, analysts often perform key-foreign key joins before learning on the join output. This strategy of learning after joins introduces redundancy avoided by normalization, which could lead to poorer end-to-end performance and maintenance overheads due to data duplication. In this work, we take a step towards enabling and optimizing learning over joins for a common class of machine learning techniques called generalized linear models that are solved using gradient descent algorithms in an RDBMS setting. We present alternative approaches to learn over a join that are easy to implement over existing RDBMSs. We introduce a new approach named factorized learning that pushes ML computations through joins and avoids redundancy in both I/O and computations. We study the tradeoff space for all our approaches both analytically and empirically. Our results show that factorized learning is often substantially faster than the alternatives, but is not always the fastest, necessitating a cost-based approach. We also discuss extensions of all our approaches to multi-table joins as well as to Hive.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1969–1984},
numpages = {16},
keywords = {feature engineering, analytics, machine learning, joins},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2750546,
author = {Katsis, Yannis and Ong, Kian Win and Papakonstantinou, Yannis and Zhao, Kevin Keliang},
title = {Utilizing IDs to Accelerate Incremental View Maintenance},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2750546},
doi = {10.1145/2723372.2750546},
abstract = {Prior Incremental View Maintenance (IVM) algorithms specify the view tuples that need to be modified by computing diff sets, which we call tuple-based diffs since a diff set contains one diff tuple for each to-be-modified view tuple. idIVM assumes the base tables have keys and performs IVM by computing ID-based diff sets that compactly identify the to-be-modified tuples through their IDs.This work makes the following contributions: (a) An ID-based IVM system for a large subset of SQL that includes the algebraic operators selection, join, grouping and aggregation, generalized projection involving functions, antisemijoin (and therefore negation/difference) and union. The system is based on a modular approach, allowing one to extend the supported language simply by adding one algebraic operator at-a-time, along with equations describing how ID-based changes are propagated through the operator. (b) An efficient algorithm that creates an IVM plan for a given view in four passes that are polynomial in the size of the view expression. (c) A formal analysis comparing the ID-based IVM algorithm to prior IVM approaches and analytically showing when one outperforms the other. (d) An experimental comparison of the ID-based IVM algorithm to prior IVM algorithms showing the superiority of the former in common use cases.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {1985–2000},
numpages = {16},
keywords = {incremental view maintenance, materialized views},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2749452,
author = {Psallidas, Fotis and Ding, Bolin and Chakrabarti, Kaushik and Chaudhuri, Surajit},
title = {S4: Top-k Spreadsheet-Style Search for Query Discovery},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2749452},
doi = {10.1145/2723372.2749452},
abstract = {An enterprise information worker is often aware of a few example tuples that should be present in the output of the query. Query discovery systems have been developed to discover project-join queries that contain the given example tuples in their output. However, they require the output to exactly contain all the example tuples and do not perform any ranking. To address this limitation, we study the problem of efficiently discovering top-k project join queries which approximately contain the given example tuples in their output. We extend our algorithms to incrementally produce results as soon as the user finishes typing/modifying a cell. Our experiments on real-life and synthetic datasets show that our proposed solution is significantly more efficient compared with applying state-of-the-art algorithms.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {2001–2016},
numpages = {16},
keywords = {relevance ranking, example spreadsheet, sql query discovery},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2749435,
author = {Ibrahim, Karim and Du, Xiao and Eltabakh, Mohamed},
title = {Proactive Annotation Management in Relational Databases},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2749435},
doi = {10.1145/2723372.2749435},
abstract = {Annotation management and data curation has been extensively studied in the context of relational databases. However, existing annotation management techniques share a common limitation, which is that they are all passive engines, i.e., they only manage the annotations obtained from external sources such as DB admins, domain experts, and curation tools. They neither learn from the available annotations nor exploit the annotations-to-data correlations to further enhance the quality of the annotated database. Delegating such crucial and complex tasks to end-users---especially under large-scale databases and annotation sets---is clearly the wrong choice. In this paper, we propose the Nebula system, an advanced and proactive annotation management engine in relational databases. Nebula complements the state-of-art techniques in annotation management by learning from the available annotations, analyzing their content and semantics, and understanding their correlations with the data. And then, Nebula proactively discovers and recommends potentially missing annotation-to-data attachments. We propose context-aware ranking and prioritization of the discovered attachments that take into account the relationships among the data tuples and their annotations. We also propose approximation techniques and expert-enabled verification mechanisms that adaptively maintain high-accuracy predictions while minimizing the experts' involvement. Nebula is realized on top of an existing annotation management engine, and experimentally evaluated to illustrate the effectiveness of the proposed techniques, and to demonstrate the potential gain in enhancing the quality of annotated databases.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {2017–2030},
numpages = {14},
keywords = {proactive annotation management, keyword search, annotated database},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2723727,
author = {Kou, Ngai Meng and U., Leong Hou and Mamoulis, Nikos and Gong, Zhiguo},
title = {Weighted Coverage Based Reviewer Assignment},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2723727},
doi = {10.1145/2723372.2723727},
abstract = {Peer reviewing is a standard process for assessing the quality of submissions at academic conferences and journals. A very important task in this process is the assignment of reviewers to papers. However, achieving an appropriate assignment is not easy, because all reviewers should have similar load and the subjects of the assigned papers should be consistent with the reviewers' expertise. In this paper, we propose a generalized framework for fair reviewer assignment. We first extract the domain knowledge from the reviewers' published papers and model this knowledge as a set of topics. Then, we perform a group assignment of reviewers to papers, which is a generalization of the classic Reviewer Assignment Problem (RAP), considering the relevance of the papers to topics as weights. We study a special case of the problem, where reviewers are to be found for just one paper (Journal Assignment Problem) and propose an exact algorithm which is fast in practice, as opposed to brute-force solutions. For the general case of having to assign multiple papers, which is too hard to be solved exactly, we propose a greedy algorithm that achieves a 1/2-approximation ratio compared to the exact solution. This is a great improvement compared to the 1/3-approximation solution proposed in previous work for the simpler coverage-based reviewer assignment problem, where there are no weights on topics. We theoretically prove the approximation bound of our solution and experimentally show that it is superior to the current state-of-the-art.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {2031–2046},
numpages = {16},
keywords = {stage deepening greedy, group coverage, paper reviewer assignment},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2737790,
author = {Tang, Mingwang and Li, Feifei and Tao, Yufei},
title = {Distributed Online Tracking},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2737790},
doi = {10.1145/2723372.2737790},
abstract = {In online tracking, an observer S receives a sequence of values, one per time instance, from a data source that is described by a function f. A tracker T wants to continuously maintain an approximation that is within an error threshold of the value f(t) at any time instance t, with small communication overhead. This problem was recently formalized and studied, and a principled approach with optimal competitive ratio was proposed. This work extends the study of online tracking to a distributed setting, where a tracker T wants to track a function f that is computed from a set of functions f1 , . . . , fm from m distributed observers and respective data sources. This formulation finds numerous important and natural applications, e.g., sensor networks, distributed systems, measurement networks, and pub-sub systems. We formalize this problem and present effective online algorithms for various topologies of a distributed system/network for different aggregate functions. Experiments on large real data sets demonstrate the excellent performance of our methods in practice.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {2047–2061},
numpages = {15},
keywords = {distributed online tracking, tracking, online tracking},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2731083,
author = {Dong, Xin Luna and Srivastava, Divesh},
title = {Knowledge Curation and Knowledge Fusion: Challenges, Models and Applications},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2731083},
doi = {10.1145/2723372.2731083},
abstract = {Large-scale knowledge repositories are becoming increasingly important as a foundation for enabling a wide variety of complex applications. In turn, building high-quality knowledge repositories critically depends on the technologies of knowledge curation and knowledge fusion, which share many similar goals with data integration, while facing even more challenges in extracting knowledge from both structured and unstructured data, across a large variety of domains, and in multiple languages.Our tutorial highlights the similarities and differences between knowledge management and data integration, and has two goals. First, we introduce the Database community to the techniques proposed for the problems of entity linkage and relation extraction by the Knowledge Management, Natural Language Processing, and Machine Learning communities. Second, we give a detailed survey of the work done by these communities in knowledge fusion, which is critical to discover and clean errors present in sources and the many mistakes made in the process of knowledge extraction from sources. Our tutorial is example driven and hopes to build bridges between the Database community and other disciplines to advance research in this important area.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {2063–2066},
numpages = {4},
keywords = {entity linkage, knowledge fusion, knowledge curation},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2764941,
author = {Yang, Mansheng and Ma, Richard T.B.},
title = {Smooth Task Migration in Apache Storm},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2764941},
doi = {10.1145/2723372.2764941},
abstract = {Task migration happens when distributed data processing systems scale in real-time. To handle the task migration process more gracefully, we propose three task migration methods: (i) worker level migration, (ii) executor level migration, and (iii) executor level migration with reliable messaging. We implement our migration methods on Apache Storm. Our experiments show that, compared with Storm's original migration implementation, our methods significantly reduce the performance degradation and the number of task failures during each migration.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {2067–2068},
numpages = {2},
keywords = {storm, distributed real-time data processing, task migration},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2764942,
author = {Babarinsa, Oreoluwatomiwa O. and Idreos, Stratos},
title = {JAFAR: Near-Data Processing for Databases},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2764942},
doi = {10.1145/2723372.2764942},
abstract = {As main-memory sizes have grown, data systems have been able to process entire large-scale data-sets in memory. However, because memory speeds have been not been keeping pace with CPU speeds, the cost of moving data into CPU caches has begun to dominate certain operations within in-memory data systems. Recent advances in hardware architectures point to near memory computation capabilities becoming possible soon. This allows us to rethink how database systems process queries and how they split computation across the various computational units. In this paper, we present JAFAR, a near data processing accelerator for pushing selects down to memory. Through a detailed simulation of JAFAR hardware we show it has the potential to provide up to 900% improvement for select operations in modern column-stores.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {2069–2070},
numpages = {2},
keywords = {column-store database, near-data processing, processing-in-memory},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2764943,
author = {Clinkenbeard, Trevor and Nica, Anisoara},
title = {Job Scheduling with Minimizing Data Communication Costs},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2764943},
doi = {10.1145/2723372.2764943},
abstract = {The research presented in this paper analyzes different algorithms for scheduling a set of potentially interdependent jobs in order to minimize the total runtime, or makespan, when data communication costs are considered. On distributed file systems, such as the HDFS, files are spread across a cluster of machines. Once a request, such as a query, having as input the data in these files is translated into a set of jobs, these jobs must be scheduled across machines in the cluster. Jobs consume input files stored in the distributed file system or in cluster nodes, and produce output which is potentially consumed by future jobs. If a job needs a particular file as input, the job must either be executed on the same machine, or it must incur a time penalty to copy the file, increasing latency for the job. At the same time, independent jobs are ideally scheduled at the same time on different machines, in order to take advantage of parallelism. Both minimizing communication costs and maximizing parallelism serve to minimize the total runtime of a set of jobs. Furthermore, the problem gets more complex when certain jobs must wait for previous jobs to provide input, as is frequently the case when a set of jobs represents the steps of a query on a distributed database.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {2071–2072},
numpages = {2},
keywords = {job scheduling, distributed databases},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2764944,
author = {Pantela, Styliani and Idreos, Stratos},
title = {One Loop Does Not Fit All},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2764944},
doi = {10.1145/2723372.2764944},
abstract = {Just-In-Time (JIT) compilation increasingly becomes a key technology for modern database systems. It allows the creation of code on-the-fly to perfectly match an active query. In the past, it has been argued that a query should be compiled to a single loop that performs all query actions, for example, all selects over all relevant columns. On the other hand, vectorization -- a common feature in modern data systems -- allows for better results by evaluating the query predicates sequentially in different tight for-loops.In this paper, we study JIT compilation for modern in-memory column-stores in detail and we show that, contrary to the common belief that vectorization outweighs the benefits of having one loop, there are cases in which creating a single loop is actually the optimal solution. In fact, deciding between multiple or a single loop is not a static decision; instead, it depends on (per column) query selectivity. We perform our experiments on a modern column-store prototype that supports vectorization and we show that, depending on selectivity, a different code layout is optimal. When a select operator is implemented with a no-branch design, for low selectivity creating multiple loops performs better than a single loop. A single tight loop performs better otherwise.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {2073–2074},
numpages = {2},
keywords = {column-stores, just-in-time code generation},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2764945,
author = {Perelman, Adam and R\'{e}, Christopher},
title = {DunceCap: Compiling Worst-Case Optimal Query Plans},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2764945},
doi = {10.1145/2723372.2764945},
abstract = {Modern data analytics workloads frequently involve complex join queries where the pairwise-join-based algorithms used by most RDBMS engines are suboptimal. In this study, we explore two algorithms that are asymptotically faster than pairwise algorithms for a large class of queries. The first is Yannakakis' classical algorithm for acyclic queries. The second is a more recent algorithm which works for any query and which is optimal with respect to the worst-case size of the output. We introduce a query compiler, DunceCap, which uses these two algorithms and variations on them to produce optimal query plans, and find that these plans can outperform standard RDBMS algorithms as well as simple worst-case optimal algorithms by an order of magnitude on a variety of queries.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {2075–2076},
numpages = {2},
keywords = {algorithms, relational joins, graph processing},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

@inproceedings{10.1145/2723372.2764946,
author = {Tu, Susan and R\'{e}, Christopher},
title = {DunceCap: Query Plans Using Generalized Hypertree Decompositions},
year = {2015},
isbn = {9781450327589},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2723372.2764946},
doi = {10.1145/2723372.2764946},
abstract = {Joins are central to data processing. However, traditional query plans for joins, which are based on choosing the order of pairwise joins, are provably suboptimal. They often perform poorly on cyclic graph queries, which have become increasingly important to modern data analytics. Other join algorithms exist: Yannakakis', for example, operates on acyclic queries in runtime proportional to the input size plus the output size cite{yannakakis}. More recently, Ngo et al. published a join algorithm that is optimal on worst-case inputs cite{worst}. My contribution is to explore query planning using these join algorithms. In our approach, every query plan can be viewed as a generalized hypertree decomposition (GHD). We score each GHD using the minimal fractional hypertree width, which Ngo et al. show allows us to bound its worst-case runtime. We benchmark our plans using datasets from the Stanford Large Network Dataset Collection cite{dataset} and find that our performance compares favorably against that of LogicBlox, a commercial system that implements a worst-case optimal join algorithm.},
booktitle = {Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data},
pages = {2077–2078},
numpages = {2},
keywords = {graph processing, joins, query planning},
location = {Melbourne, Victoria, Australia},
series = {SIGMOD '15}
}

license: Unlicense

repository: goyalkaraniit/acm-cr

repo_name: goyalkaraniit/acm-cr


text:
:root {
	--sapUiBrand: var(--sapBrandColor);
	--sapUiHighlight: var(--sapHighlightColor);
	--sapUiBaseColor: var(--sapBaseColor);
	--sapUiShellColor: var(--sapShellColor);
	--sapUiBaseBG: var(--sapBackgroundColor);
	--sapUiGlobalBackgroundColor: var(--sapBackgroundColor);
	--sapUiFontFamily: var(--sapFontFamily);
	--sapUiFontSize: 16px;
	--sapUiBaseText: var(--sapTextColor);
	--sapUiLink: var(--sapLinkColor);
	--sapUiGlobalLogo: var(--sapCompanyLogo);
	--sapUiGlobalBackgroundImage: var(--sapBackgroundImage);
	--sapUiBackgroundImage: var(--sapBackgroundImage);
	--sapUiUx3ShellBackgroundImageURL: var(--sapBackgroundImage);
	--sapUiGlobalBackgroundImageOpacity: var(--sapBackgroundImageOpacity);
	--sapUiGlobalBackgroundRepeat: var(--sapBackgroundImageRepeat);
	--sapUiSelected: var(--sapSelectedColor);
	--sapUiActive: var(--sapActiveColor);
	--sapUiHighlightTextColor: var(--sapHighlightTextColor);
	--sapUiTextTitle: var(--sapTitleColor);
	--sapUiElementLineHeight: var(--sapElement_LineHeight);
	--sapUiElementHeight: var(--sapElement_Height);
	--sapUiElementBorderWidth: var(--sapElement_BorderWidth);
	--sapUiContentLineHeight: var(--sapContent_LineHeight);
	--sapUiContentElementHeight: var(--sapContent_ElementHeight);
	--sapUiContentElementHeightPX: var(--sapContent_ElementHeight_PX);
	--sapUiContentIconHeight: var(--sapContent_IconHeight);
	--sapUiContentIconColor: var(--sapContent_IconColor);
	--sapUiContentContrastIconColor: var(--sapContent_ContrastIconColor);
	--sapUiContentNonInteractiveIconColor: var(--sapContent_NonInteractiveIconColor);
	--sapUiContentMarkerIconColor: var(--sapContent_MarkerIconColor);
	--sapUiContentMarkerTextColor: var(--sapContent_MarkerTextColor);
	--sapUiContentImagePlaceholderBackground: var(--sapContent_ImagePlaceholderBackground);
	--sapUiContentImagePlaceholderForegroundColor: var(--sapContent_ImagePlaceholderForegroundColor);
	--sapUiContentFocusColor: var(--sapContent_FocusColor);
	--sapUiContentContrastFocusColor: var(--sapContent_ContrastFocusColor);
	--sapUiContentShadowColor: var(--sapContent_ShadowColor);
	--sapUiContentContrastShadowColor: var(--sapContent_ContrastShadowColor);
	--sapUiContentSearchHighlightColor: var(--sapContent_SearchHighlightColor);
	--sapUiContentHelpColor: var(--sapContent_HelpColor);
	--sapUiContentLabelColor: var(--sapContent_LabelColor);
	--sapUiContentDisabledTextColor: var(--sapContent_DisabledTextColor);
	--sapUiContentDisabledOpacity: var(--sapContent_DisabledOpacity);
	--sapUiContentContrastTextThreshold: var(--sapContent_ContrastTextThreshold);
	--sapUiContentContrastTextColor: var(--sapContent_ContrastTextColor);
	--sapUiContentForegroundColor: var(--sapContent_ForegroundColor);
	--sapUiContentForegroundBorderColor: var(--sapContent_ForegroundBorderColor);
	--sapUiContentForegroundTextColor: var(--sapContent_ForegroundTextColor);
	--sapUiContentBadgeBackground: var(--sapContent_BadgeBackground);
	--sapUiShellBackground: var(--sapShell_Background);
	--sapUiShellBackgroundImage: var(--sapShell_BackgroundImage);
	--sapUiShellBackgroundImageOpacity: var(--sapShell_BackgroundImageOpacity);
	--sapUiShellBackgroundImageRepeat: var(--sapShell_BackgroundImageRepeat);
	--sapUiShellBackgroundPatternColor: var(--sapShell_BackgroundPatternColor);
	--sapUiShellBackgroundGradient: var(--sapShell_BackgroundGradient);
	--sapUiShellBorderColor: var(--sapShell_BorderColor);
	--sapUiShellTextColor: var(--sapShell_TextColor);
	--sapUiShellInteractiveTextColor: var(--sapShell_InteractiveTextColor);
	--sapUiShellFavicon: var(--sapShell_Favicon);
	--sapUiButtonBorderWidth: var(--sapButton_BorderWidth);
	--sapUiButtonBorderCornerRadius: var(--sapButton_BorderCornerRadius);
	--sapUiButtonBackground: var(--sapButton_Background);
	--sapUiButtonBorderColor: var(--sapButton_BorderColor);
	--sapUiButtonTextColor: var(--sapButton_TextColor);
	--sapUiButtonHoverBackground: var(--sapButton_Hover_Background);
	--sapUiButtonHoverBorderColor: var(--sapButton_Hover_BorderColor);
	--sapUiButtonHoverTextColor: var(--sapButton_Hover_TextColor);
	--sapUiButtonEmphasizedBackground: var(--sapButton_Emphasized_Background);
	--sapUiButtonEmphasizedBorderColor: var(--sapButton_Emphasized_BorderColor);
	--sapUiButtonEmphasizedTextColor: var(--sapButton_Emphasized_TextColor);
	--sapUiButtonRejectBackground: var(--sapButton_Reject_Background);
	--sapUiButtonAcceptBackground: var(--sapButton_Accept_Background);
	--sapUiFieldBorderWidth: var(--sapField_BorderWidth);
	--sapUiFieldBorderCornerRadius: var(--sapField_BorderCornerRadius);
	--sapUiFieldBackground: var(--sapField_Background);
	--sapUiFieldBorderColor: var(--sapField_BorderColor);
	--sapUiFieldTextColor: var(--sapField_TextColor);
	--sapUiFieldHelpBackground: var(--sapField_HelpBackground);
	--sapUiFieldHoverBackground: var(--sapField_Hover_Background);
	--sapUiFieldHoverBorderColor: var(--sapField_Hover_BorderColor);
	--sapUiFieldHoverHelpBackground: var(--sapField_Hover_HelpBackground);
	--sapUiFieldFocusBackground: var(--sapField_Focus_Background);
	--sapUiFieldFocusBorderColor: var(--sapField_Focus_BorderColor);
	--sapUiFieldFocusHelpBackground: var(--sapField_Focus_HelpBackground);
	--sapUiFieldReadOnlyBackground: var(--sapField_ReadOnly_Background);
	--sapUiFieldReadOnlyBorderColor: var(--sapField_ReadOnly_BorderColor);
	--sapUiFieldReadOnlyHelpBackground: var(--sapField_ReadOnly_HelpBackground);
	--sapUiFieldRequiredColor: var(--sapField_RequiredColor);
	--sapUiFieldInvalidColor: var(--sapField_InvalidColor);
	--sapUiFieldInvalidBackground: var(--sapField_InvalidBackground);
	--sapUiFieldWarningColor: var(--sapField_WarningColor);
	--sapUiFieldWarningBackground: var(--sapField_WarningBackground);
	--sapUiFieldSuccessColor: var(--sapField_SuccessColor);
	--sapUiFieldSuccessBackground: var(--sapField_SuccessBackground);
	--sapUiGroupTitleBackground: var(--sapGroup_TitleBackground);
	--sapUiGroupTitleBorderColor: var(--sapGroup_TitleBorderColor);
	--sapUiGroupTitleTextColor: var(--sapGroup_TitleTextColor);
	--sapUiGroupContentBackground: var(--sapGroup_ContentBackground);
	--sapUiGroupContentBorderColor: var(--sapGroup_ContentBorderColor);
	--sapUiGroupBorderWidth: var(--sapGroup_BorderWidth);
	--sapUiGroupFooterBackground: var(--sapGroup_FooterBackground);
	--sapUiToolbarBackground: var(--sapToolbar_Background);
	--sapUiToolbarSeparatorColor: var(--sapToolbar_SeparatorColor);
	--sapUiListHeaderBackground: var(--sapList_HeaderBackground);
	--sapUiListHeaderBorderColor: var(--sapList_HeaderBorderColor);
	--sapUiListHeaderTextColor: var(--sapList_HeaderTextColor);
	--sapUiListBorderColor: var(--sapList_BorderColor);
	--sapUiListBorderWidth: var(--sapList_BorderWidth);
	--sapUiListHighlightColor: var(--sapList_HighlightColor);
	--sapUiListSelectionBackgroundColor: var(--sapList_SelectionBackgroundColor);
	--sapUiListBackground: var(--sapList_Background);
	--sapUiListHoverBackground: var(--sapList_Hover_Background);
	--sapUiScrollBarFaceColor: var(--sapScrollBar_FaceColor);
	--sapUiScrollBarTrackColor: var(--sapScrollBar_TrackColor);
	--sapUiScrollBarBorderColor: var(--sapScrollBar_BorderColor);
	--sapUiScrollBarSymbolColor: var(--sapScrollBar_SymbolColor);
	--sapUiScrollBarDimension: var(--sapScrollBar_Dimension);
	--sapUiScrollBarHoverFaceColor: var(--sapScrollBar_Hover_FaceColor);
	--sapUiPageHeaderBackground: var(--sapPageHeader_Background);
	--sapUiPageHeaderBorderColor: var(--sapPageHeader_BorderColor);
	--sapUiPageHeaderTextColor: var(--sapPageHeader_TextColor);
	--sapUiPageFooterBackground: var(--sapPageFooter_Background);
	--sapUiPageFooterTextColor: var(--sapPageFooter_TextColor);
	--sapUiInfobarBackground: var(--sapInfobar_Background);
	--sapUiObjectHeaderBackground: var(--sapObjectHeader_Background);
	--sapUiBlockLayerBackground: var(--sapBlockLayer_Background);
	--sapUiTileBackground: var(--sapTile_Background);
	--sapUiTileBorderColor: var(--sapTile_BorderColor);
	--sapUiTileTitleTextColor: var(--sapTile_TitleTextColor);
	--sapUiTileTextColor: var(--sapTile_TextColor);
	--sapUiTileIconColor: var(--sapTile_IconColor);

	--sapUiContentGridSize: var(--sapContent_GridSize);
	--sapUiPrimary1: var(--sapPrimary1);
	--sapUiPrimary2: var(--sapPrimary2);
	--sapUiPrimary3: var(--sapPrimary3);
	--sapUiPrimary4: var(--sapPrimary4);
	--sapUiPrimary5: var(--sapPrimary5);
	--sapUiPrimary6: var(--sapPrimary6);
	--sapUiPrimary7: var(--sapPrimary7);
	--sapUiAccent1: var(--sapAccentColor1);
	--sapUiAccent2: var(--sapAccentColor2);
	--sapUiAccent3: var(--sapAccentColor3);
	--sapUiAccent4: var(--sapAccentColor4);
	--sapUiAccent5: var(--sapAccentColor5);
	--sapUiAccent6: var(--sapAccentColor6);
	--sapUiAccent7: var(--sapAccentColor7);
	--sapUiAccent8: var(--sapAccentColor8);
	--sapUiAccent9: var(--sapAccentColor9);
	--sapUiAccent10: var(--sapAccentColor10);
	--sapUiErrorBG: var(--sapErrorBackground);
	--sapUiWarningBG: var(--sapWarningBackground);
	--sapUiSuccessBG: var(--sapSuccessBackground);
	--sapUiInformationBG: var(--sapInformationBackground);
	--sapUiNeutralBG: var(--sapNeutralBackground);
	--sapUiErrorBorder: var(--sapErrorBorderColor);
	--sapUiWarningBorder: var(--sapWarningBorderColor);
	--sapUiSuccessBorder: var(--sapSuccessBorderColor);
	--sapUiInformationBorder: var(--sapInformationBorderColor);
	--sapUiNeutralBorder: var(--sapNeutralColor);
	--sapUiNegativeElement: var(--sapNegativeElementColor);
	--sapUiCriticalElement: var(--sapCriticalElementColor);
	--sapUiPositiveElement: var(--sapPositiveElementColor);
	--sapUiInformativeElement: var(--sapInformativeElementColor);
	--sapUiNeutralElement: var(--sapNeutralElementColor);
	--sapUiNegativeText: var(--sapNegativeTextColor);
	--sapUiCriticalText: var(--sapCriticalTextColor);
	--sapUiPositiveText: var(--sapPositiveTextColor);
	--sapUiInformativeText: var(--sapInformativeTextColor);
	--sapUiNeutralText: var(--sapNeutralTextColor);
	--sapUiNegative: var(--sapNegativeColor);
	--sapUiCritical: var(--sapCriticalColor);
	--sapUiPositive: var(--sapPositiveColor);
	--sapUiInformative: var(--sapInformativeColor);
	--sapUiNeutral: var(--sapNeutralColor);
	--sapUiIndication1: var(--sapIndicationColor_1);
	--sapUiIndication2: var(--sapIndicationColor_2);
	--sapUiIndication3: var(--sapIndicationColor_3);
	--sapUiIndication4: var(--sapIndicationColor_4);
	--sapUiIndication5: var(--sapIndicationColor_5);
	--sapUiFontCondensedFamily: "72 Condensed", 'Arial Narrow', HelveticaNeue-CondensedBold, Arial, sans-serif;
	--sapUiFontHeaderFamily: var(--sapUiFontFamily);
	--sapUiFontHeaderWeight: normal;
	--sapMFontHeader1Size: 2.25rem;
	--sapMFontHeader2Size: 1.5rem;
	--sapMFontHeader3Size: 1.250rem;
	--sapMFontHeader4Size: 1.125rem;
	--sapMFontHeader5Size: 1rem;
	--sapMFontHeader6Size: 0.875rem;
	--sapMFontSmallSize: 0.75rem;
	--sapMFontMediumSize: 0.875rem;
	--sapMFontLargeSize: 1rem;
	--sapUiTranslucentBGOpacity: 0;
	--sapMPlatformDependent: false;
	--sapUiDesktopFontFamily: var(--sapUiFontFamily);
	--sapUiDesktopFontSize: 12px;
	--sapUiFontLargeSize: 13px;
	--sapUiFontSmallSize: 11px;
	--sapUiFontHeader1Size: 26px;
	--sapUiFontHeader2Size: 20px;
	--sapUiFontHeader3Size: 18px;
	--sapUiFontHeader4Size: 16px;
	--sapUiFontHeader5Size: 14px;
	--sapUiFontHeader6Size: var(--sapUiFontLargeSize);
	--sapUiLineHeight: 18px;

	--sapUiShellContainerBackground: var(--sapUiGroupContentBackground);
	--sapUiShellAltContainerBackground: var(--sapUiShellContainerBackground);
	--sapUiShellGroupTextColor: var(--sapUiTextTitle);
	--sapUiLinkActive: var(--sapUiLink);
	--sapUiLinkVisited: var(--sapUiLink);

	--sapUiNotifierSeparatorWidth: 1px;

	--sapUiButtonActiveBackground: var(--sapUiActive);
	--sapUiButtonActiveBorderColor: var(--sapUiButtonActiveBackground);

	--sapUiButtonEmphasizedHoverBorderColor: var(--sapUiButtonEmphasizedHoverBackground);
	--sapUiButtonEmphasizedActiveBorderColor: var(--sapUiButtonEmphasizedActiveBackground);
	--sapUiButtonEmphasizedTextShadow: transparent;
	--sapUiButtonAcceptBorderColor: var(--sapUiPositiveElement);
	--sapUiButtonAcceptHoverBackground: var(--sapUiSuccessBG);
	--sapUiButtonAcceptHoverBorderColor: var(--sapUiButtonAcceptBorderColor);
	--sapUiButtonAcceptActiveBorderColor: var(--sapUiButtonAcceptActiveBackground);
	--sapUiButtonRejectBorderColor: var(--sapUiNegativeElement);
	--sapUiButtonRejectHoverBackground: var(--sapUiErrorBG);
	--sapUiButtonRejectHoverBorderColor: var(--sapUiButtonRejectBorderColor);
	--sapUiButtonRejectActiveBorderColor: var(--sapUiButtonRejectActiveBackground);
	--sapUiButtonLiteBackground: transparent;
	--sapUiButtonLiteBorderColor: transparent;
	--sapUiButtonLiteTextColor: var(--sapUiButtonTextColor);
	--sapUiButtonLiteHoverBackground: var(--sapUiButtonHoverBackground);
	--sapUiButtonLiteHoverBorderColor: var(--sapUiButtonLiteHoverBackground);
	--sapUiButtonLiteActiveBackground: var(--sapUiButtonActiveBackground);
	--sapUiButtonLiteActiveBorderColor: var(--sapUiButtonLiteActiveBackground);
	--sapUiButtonHeaderTextColor: var(--sapUiButtonTextColor);
	--sapUiButtonHeaderDisabledTextColor: var(--sapUiButtonHeaderTextColor);
	--sapUiButtonFooterHoverBackground: var(--sapUiButtonLiteHoverBackground);
	--sapUiButtonActionSelectBackground: var(--sapUiListBackground);
	--sapUiButtonActionSelectBorderColor: var(--sapUiListBorderColor);
	--sapUiButtonLiteActionSelectHoverBackground: var(--sapUiListHoverBackground);
	--sapUiToggleButtonPressedBackground: var(--sapUiSelected);
	--sapUiToggleButtonPressedBorderColor: var(--sapUiToggleButtonPressedBackground);
	--sapUiToggleButtonPressedHoverBorderColor: var(--sapUiToggleButtonPressedHoverBackground);
	--sapUiSegmentedButtonBackground: var(--sapUiButtonBackground);
	--sapUiSegmentedButtonBorderColor: var(--sapUiButtonBorderColor);

	--sapUiSegmentedButtonHoverBackground: var(--sapUiButtonHoverBackground);
	--sapUiSegmentedButtonActiveBackground: var(--sapUiButtonActiveBackground);
	--sapUiSegmentedButtonSelectedBackground: var(--sapUiToggleButtonPressedBackground);
	--sapUiSegmentedButtonSelectedTextColor: var(--sapUiToggleButtonPressedTextColor);
	--sapUiSegmentedButtonSelectedHoverBackground: var(--sapUiToggleButtonPressedHoverBackground);
	--sapUiSegmentedButtonSelectedHoverBorderColor: var(--sapUiToggleButtonPressedHoverBorderColor);
	--sapUiSegmentedButtonFooterBorderColor: var(--sapUiSegmentedButtonBorderColor);
	--sapUiSegmentedButtonFooterHoverBackground: var(--sapUiSegmentedButtonHoverBackground);
	--sapUiFieldActiveBackground: var(--sapUiActive);
	--sapUiFieldActiveBorderColor: var(--sapUiActive);
	--sapUiFieldActiveTextColor: var(--sapUiContentContrastTextColor);
	--sapUiListTextColor: var(--sapUiBaseText);
	--sapUiListVerticalBorderColor: var(--sapUiListBorderColor);
	--sapUiListActiveBackground: var(--sapUiListHighlightColor);
	--sapUiListFooterTextColor: var(--sapUiListTextColor);
	--sapUiListGroupHeaderBackground: var(--sapUiListBackground);

	--sapUiListTableFooterBorder: var(--sapUiListBorderColor);
	--sapUiListTableTextSize: 0.875rem;
	--sapUiListTableIconSize: 1rem;

	--sapUiInfobarActiveBackground: var(--sapUiListActiveBackground);
	--sapUiCalendarColorToday: var(--sapUiAccent4);
	--sapUiDragAndDropColor: var(--sapUiContentNonInteractiveIconColor);
	--sapUiDragAndDropBackground: var(--sapUiGroupContentBackground);
	--sapUiDragAndDropBorderColor: var(--sapUiContentForegroundBorderColor);
	--sapUiDragAndDropActiveColor: var(--sapUiLink);
	--sapUiDragAndDropActiveBorderColor: var(--sapUiLink);
}

license: MIT

repository: jbadan/shared-styles

license_type: permissive

repo_name: jbadan/shared-styles

branch_name: refs/heads/master

gha_license_id: MIT

gha_language: CSS

extension: css