flink-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Luke Hutchison (JIRA)" <j...@apache.org>
Subject [jira] [Created] (FLINK-6070) Suggestion: add ComparableTuple types
Date Thu, 16 Mar 2017 08:54:41 GMT
Luke Hutchison created FLINK-6070:
-------------------------------------

             Summary: Suggestion: add ComparableTuple types
                 Key: FLINK-6070
                 URL: https://issues.apache.org/jira/browse/FLINK-6070
             Project: Flink
          Issue Type: Improvement
          Components: Core
    Affects Versions: 1.2.0
            Reporter: Luke Hutchison
            Priority: Minor


Since Java doesn't have built-in tuple types, I find myself using Flink tuples for a lot of
tasks in Flink programs. One downside is that these tuples are not inherently comparable,
so when you want to sort a collection of tuples, you have to provide a custom comparator.

I created a ComparableTuple2 type, as follows. I wanted to get feedback on whether something
like this would be considered useful for Flink before I submitted a PR. Also, I don't know
how high I should go with the field arity for a ComparableTuple -- presumably not as high
as for non-comparable tuples?

{code}
import org.apache.flink.api.java.tuple.Tuple2;

/** A comparable tuple, consisting of comparable fields that act as primary and secondary
sort keys. */
public class ComparableTuple2<T0 extends Comparable<T0>, T1 extends Comparable<T1>>
extends Tuple2<T0, T1>
        implements Comparable<Tuple2<T0, T1>> {
    private static final long serialVersionUID = 1L;

    private boolean invertSortOrder0;
    private boolean invertSortOrder1;

    public ComparableTuple2() {
    }

    /**
     * Create a 2-tuple of comparable elements.
     * 
     * @param f0
     *            The first element, which is also the primary sort key, and sorts in ascending
order.
     * @param f1
     *            The second element, which is also the secondary sort key, and sorts in ascending
order.
     * @param invertSortOrder0
     *            If true, invert the sort order for the first field (i.e. sort in descending
order).
     * @param invertSortOrder1
     *            If true, invert the sort order for the second field (i.e. sort in descending
order).
     */
    public ComparableTuple2(T0 f0, T1 f1) {
        super(f0, f1);
    }

    /**
     * Create a comparable 2-tuple out of comparable elements.
     * 
     * @param f0
     *            The first element, which is also the primary sort key, and sorts in ascending
order if
     *            invertSortOrder0 == false, else sorts in descending order.
     * @param f1
     *            The second element, which is also the secondary sort key, and sorts in decending
order if
     *            invertSortOrder1 == false, else sorts in descending order.
     * @param invertSortOrder0
     *            If true, invert the sort order for the first field (i.e. sort in descending
order).
     * @param invertSortOrder1
     *            If true, invert the sort order for the second field (i.e. sort in descending
order).
     */
    public ComparableTuple2(final T0 f0, final T1 f1, final boolean invertSortOrder0,
            final boolean invertSortOrder1) {
        super(f0, f1);
        this.invertSortOrder0 = invertSortOrder0;
        this.invertSortOrder1 = invertSortOrder1;
    }

    /**
     * Comparison function that compares first the primary sort key, f0, and then if equal,
compares the secondary sort
     * key, f1.
     */
    @Override
    public int compareTo(final Tuple2<T0, T1> o) {
        int diff = this.f0.compareTo(o.f0);
        if (invertSortOrder0) {
            diff = -diff;
        }
        if (diff != 0) {
            return diff;
        }
        diff = this.f1.compareTo(o.f1);
        if (invertSortOrder1) {
            diff = -diff;
        }
        return diff;
    }
}
{code}



--
This message was sent by Atlassian JIRA
(v6.3.15#6346)

Mime
View raw message