Tuple

About: Tuple is a research topic. Over the lifetime, 6513 publications have been published within this topic receiving 146057 citations. The topic is also known as: tuple & ordered tuplet.

On similarity measures for multimedia database applications

Abstract: A multimedia database query consists of a set of fuzzy and boolean (or crisp) predicates, constants, variables, and conjunction, disjunction, and negation operators. The fuzzy predicates are evaluated based on different media criteria, such as color, shape, layout, keyword. Since media-based evaluation yields similarity values, results to such a query is defined as an ordered set. Since many multimedia applications require partial matches, query results also include tuples which do not satisfy all predicates. Hence, any fuzzy semantics which extends the boolean semantics of conjunction in a straight forward manner may not be desirable for multimedia databases. In this paper, we focus on the problem of ‘given a multimedia query which consists of multiple fuzzy and crisp predicates, how to provide the user with a meaningful overall ranking.’ More specifically, we study the problem of merging similarity values in queries with multiple fuzzy predicates. We describe the essential multimedia retrieval semantics, compare these with the known approaches, and propose a semantics which captures the retrieval requirements in multimedia databases.

Visual debugging for stream processing applications

Abstract: Stream processing is a new computing paradigm that enables continuous and fast analysis of massive volumes of streaming data. Debugging streaming applications is not trivial, since they are typically distributed across multiple nodes and handle large amounts of data. Traditional debugging techniques like breakpoints often rely on a stop-the-world approach, which may be useful for debugging single node applications, but insufficient for streaming applications. We propose a new visual and analytic environment to support debugging, performance analysis, and troubleshooting for stream processing applications. Our environment provides several visualization methods to study, characterize, and summarize the flow of tuples between stream processing operators. The user can interactively indicate points in the streaming application from where tuples will be traced and visualized as they flow through different operators, without stopping the application. To substantiate our discussion, we also discuss several of these features in the context of a financial engineering application.

Reconcilable differences

Abstract: Exact query reformulation using views in positive relational languages is well understood, and has a variety of applications in query optimization and data sharing. Generalizations to larger fragments of the relational algebra (RA) --- specifically, support for the difference operator --- would increase the options available for query reformulation, and also apply to view adaptation (updating a materialized view in response to a modified view definition) and view maintenance. Unfortunately, most questions about queries become undecidable in the presence of difference/negation. We present a novel way of managing this difficulty via an excursion through a non-standard semantics, Z-relations, where tuples are annotated with positive or negative integers.We show that under Z-semantics RA queries have a normal form as a single difference of positive queries and this leads to the decidability of equivalence. In most real-world settings with difference, it is possible to convert the queries to this normal form. We give a sound and complete algorithm that explores all reformulations of an RA query (under Z-semantics) using a set of RA views, finitely bounding the search space with a simple and natural cost model. We investigate related complexity questions, and we also extend our results to queries with built-in predicates.Z-relations are interesting in their own right because they capture updates and data uniformly. However, our algorithm turns out to be sound and complete also for bag semantics, albeit necessarily only for a subclass of RA. This subclass turns out to be quite large and covers generously the applications of interest to us. We also show a subclass of RA where reformulation and evaluation under Z-semantics can be combined with duplicate elimination to obtain the answer under set semantics.

The expressive power of temporal relational query languages

Abstract: The authors consider the representation of temporal data based on tuple and attribute timestamping. They identify the requirements in modeling temporal data and elaborate on their implications in the expressive power of temporal query languages. They introduce a temporal relational data model where N1NF relations and attribute timestamping are used and one level of nesting is allowed. For this model, a nested relational tuple calculus (NTC) is defined. They follow a comparative approach in evaluating the expressive power of temporal query languages, using NTC as a metric and comparing it with the existing temporal query languages. They prove that NTC subsumes the expressive power of these query languages. They also demonstrate how various temporal relational models can be obtained from the temporal relations by NTC and give equivalent NTC expressions for their languages. Furthermore, they show the equivalence of intervals and temporal elements (sets) as timestamps in their model.

Finding $$k$$k most favorite products based on reverse top-$$t$$t queries

Abstract: A reverse top-t query for a product returns a set of customers, named potential customers, who regard the product as one of their top-t favorites. Given a set of customers with different preferences on the features of the products, we want to select at most $$k$$ k products from a pool of candidate products such that their total number of potential customers is maximized. Two versions of the problem are defined according to whether the competitive existing products are given. For solving this NP-hard problem, we first propose an incremental greedy approach to find an approximate solution of the problem with quality guaranteed. For further speeding up this basic greedy approach, we exploit several properties of the top- $$t$$ t queries and skyline queries to reduce the solution space of the problem. In addition, an upper bound of the potential customers is estimated to reduce the cost of computing the reverse top- $$t$$ t queries for the candidate products. Finally, when the candidate products are formed from multiple component tables, we propose a strategy to reduce the number of the accessed tuples in the component tables such that only the tuples that are possibly components of the top- $$t$$ t favorites of the customers need to be accessed. By applying these pruning strategies, we propose another faster greedy approach. The experiment results demonstrate that the proposed pruning strategies work very well and make the faster greedy algorithms for both versions of the problem achieve excellent performance on both efficiency and memory utilization.