join

Documentation

Overview

Package join implements a generic interface for matching elements from two slices similar in spirit to a database Join.

Index

• type List
• type Pair
  • func HashJoin(lSlice, rSlice List, lKey, rKey func(interface{}) interface{}) (pairs []Pair, lonelyLefts, lonelyRights []interface{})
  • func Join(lSlice, rSlice interface{}, score func(left, right interface{}) int) (pairs []Pair, lonelyLefts, lonelyRights []interface{})
• type StringSlice
  • func (ss StringSlice) Get(ii int) interface{}
  • func (ss StringSlice) Len() int

Examples

• Join

Types

type List

type List interface {
	Len() int
	Get(int) interface{}
}

List simply requires implementing types to allow access to their contained values by integer index.

type Pair

type Pair struct {
	L, R interface{}
}

A Pair represents an element from the left slice and an element from the right slice, that have been matched by a join.

func HashJoin

func HashJoin(lSlice, rSlice List, lKey, rKey func(interface{}) interface{}) (
	pairs []Pair, lonelyLefts, lonelyRights []interface{})

HashJoin attempts to match each element in `lSlice` with an element in `rSlice` by performing a hash join. If such a match is found for a given element of `lSlice`, it is returned as an element of `pairs`, while leftover elements from `lSlice` and `rSlice` that couldn`t be matched are returned as elements of `lonelyLefts` and `lonelyRights` respectively. The join keys for `lSlice` and `rSlice` are defined by the passed in `lKey` and `rKey` functions, respectively.

If `lKey` or `rKey` are nil, the elements of the respective slices are used directly as keys instead.

func Join

func Join(lSlice, rSlice interface{}, score func(left, right interface{}) int) (
	pairs []Pair, lonelyLefts, lonelyRights []interface{})

Join attempts to match each element in `lSlice` with an element in `rSlice` in accordance with a score function. If such a match is found, it is returned as an element of `pairs`, while leftover elements from `lSlice` and `rSlice` that couldn`t be matched, are returned as elements of `lonelyLefts` and `lonelyRights` respectively. Both `lSlice` and `rSlice` must be slice or array types, but they do not necessarily have to have the same type.

Matches are made in accordance with the provided `score` function. It takes a single element from `lSlice`, and a single element from `rSlice`, and computes a score representing the match priority. The algorithm strictly prioritizes lower scoring matches first, but negative scores are never matched. The algorithm does not minimize the total score of all matches.

Example

lefts := []string{"a", "bc", "def"}
rights := []int{0, 2, 4}
score := func(left, right interface{}) int {
	return len(left.(string)) - right.(int)
}
pairs, lonelyLefts, lonelyRights := Join(lefts, rights, score)

fmt.Println(pairs, lonelyLefts, lonelyRights)

Output:

[{bc 2} {a 0}] [def] [4]

type StringSlice

type StringSlice []string

StringSlice is an alias for []string to allow for joins

func (StringSlice) Get

func (ss StringSlice) Get(ii int) interface{}

Get returns the value contained at the given index

func (StringSlice) Len

func (ss StringSlice) Len() int

Len returns the number of items in the slice