Sort-merge join

The sort-merge join (also known as merge join) is a join algorithm and is used in the implementation of a relational database management system.

The basic problem of a join algorithm is to find, for each distinct value of the join attribute, the set of tuples in each relation which display that value. The key idea of the sort-merge algorithm is to first sort the relations by the join attribute, so that interleaved linear scans will encounter these sets at the same time.

In practice, the most expensive part of performing a sort-merge join is arranging for both inputs to the algorithm to be presented in sorted order. This can be achieved via an explicit sort operation (often an external sort), or by taking advantage of a pre-existing ordering in one or both of the join relations. The latter condition, called interesting order, can occur because an input to the join might be produced by an index scan of a tree-based index, another merge join, or some other plan operator that happens to produce output sorted on an appropriate key. Interesting orders need not be serendipitous: the optimizer may seek out this possibility and choose a plan that is suboptimal for a specific preceding operation if it yields an interesting order that one or more downstream nodes can exploit.

Complexity
Let $$R$$ and $$S$$ be relations where $$ |R|<|S| $$. $$R$$ fits in $$P_{r}$$ pages memory and $$S$$ fits in $$P_{s}$$ pages memory. In the worst case, a sort-merge join will run in $$O(P_{r}+P_{s})$$ I/O operations. In the case that $$R$$ and $$S$$ are not ordered the worst case time cost will contain additional terms of sorting time: $$O(P_{r}+P_{s}+P_{r}\log(P_{r})+ P_{s}\log(P_{s}))$$, which equals $$O(P_{r}\log(P_{r})+ P_{s}\log(P_{s}))$$ (as linearithmic terms outweigh the linear terms, see Big O notation – Orders of common functions).

Pseudocode
For simplicity, the algorithm is described in the case of an inner join of two relations left and right. Generalization to other join types is straightforward. The output of the algorithm will contain only rows contained in the left and right relation and duplicates form a Cartesian product.

Since the comparison logic is not the central aspect of this algorithm, it is hidden behind a generic comparator and can also consist of several comparison criteria (e.g. multiple columns). The compare function should return if a row is less(-1), equal(0) or bigger(1) than another row:

Note that a relation in terms of this pseudocode supports some basic operations:

Simple C# implementation
Note that this implementation assumes the join attributes are unique, i.e., there is no need to output multiple tuples for a given value of the key.