join0(USP)

Name

join0 : Selects the lines from Master with a matching key field

Synopsis

Usage   : join0 key=<key> <master> <tran>

Options : +ng[<fd>]

          -e

          -s<c>

Version : Tue Jan  9 09:02:34 JST 2024

Edition : 1

Description

Selects all records from <tran> where the <key> fields match

corresponding fields of <master>.

The <key> fields in <master> and <tran> MUST be sorted.  Also, the

key fields in <master> must only contain unique values (the same

value cannot be repeated in the <key> fields).  The <key> fields in

<tran> do not have this requirement; multiple records in <tran> can

have the same value in the <key> fields.

<key> designates the field position as fllows:

single field       2        the 2nd field

                   NF   the last field

                   NF-1   the field just before the last field

contiguous fields  2/4      from the 2nd field to the 4th field

                   4/2   from the 4th field to the 2nd field

                   NF-3/NF  from NF-3 field to the NF field

combination        2@NF     the 2nd field and the NF field

There is no limit on the length of the key field or on the number

of key fields.  The key field can also contain multi-byte characters

such as Japanese.

If you specify "r" as comparison method after the field position,

the fields are compared in reverse order.  If you specify "n" as

comparison method after the field position, that field's values will

be compared as numbers.  If you specify "nr" as comparison method

after the field, the values will be compared in reverse order as

numbers.  If you specify comparison method before or after the "/",

you must use the same comparison method for both fields.

  2n/5n     OK

  2n/5nr    Error

  2n/5r     Error

When you specify "e" as comparison method or specify -e ootion and no

method, characters in the field are replaced as follows and compared

as string:

  _  ==> 0x20 (space)

  \0 ==> 0x00 (null)

  \t ==> 0x09 (tab stop)

  \n ==> 0x0a (new line)

  \r ==> 0x0d (carrige return)

  \_ ==> 0x5f (underscore)

  \\ ==> 0x5c (back slash)

Example 1 Basic Pattern

Select the four students from the grade file "grades" file who are

listed in the "master" file.

(Master File: master)

$ cat master

0000003 Wilson_____ 26 F

0000005 Hawking____ 50 F

0000007 Newton_____ 42 F

0000010 Tesla______ 50 F

(Transaction File: grades)

$ cat grades

A 0000000 91 59 20 76 54

A 0000001 46 39 8  5 21

A 0000003 30 50 71 36 30

A 0000004 58 71 20 10 6

A 0000005 82 79 16 21 80

A 0000007 50 2  33 15 62

A 0000008 52 91 44 9  0

A 0000009 60 89 33 18 6

A 0000010 95 60 35 93 76

A 0000011 92 56 83 96 75

Only records where the second field of "grades" exist in the

"master" file are selected.

$ join0 key=2 master grades > data

$ cat data

A 0000003 30 50 71 36 30

A 0000005 82 79 16 21 80

A 0000007 50 2  33 15 62

A 0000010 95 60 35 93 76

Example 2

When specifying multiple continuous fields starting on the left as

the key fields.

(Master: master)

$ cat master

A 0000003 Wilson_____ 26 F

A 0000005 Hawking____ 50 F

B 0000007 Newton_____ 42 F

C 0000010 Tesla______ 50 F

(Transaction: grades)

$ cat grades

01 A 0000000 91 59 20 76 54

02 A 0000001 46 39 8  5 21

03 A 0000003 30 50 71 36 30

04 A 0000004 58 71 20 10 6

05 A 0000005 82 79 16 21 80

06 B 0000007 50 2  33 15 62

07 B 0000008 52 91 44 9  0

08 C 0000009 60 89 33 18 6

09 C 0000010 95 60 35 93 76

10 C 0000011 92 56 83 96 75

Select only records that exist in the "master" file second and third

fields.

$ join0 key=2/3 master grades > data

03 A 0000003 30 50 71 36 30

05 A 0000005 82 79 16 21 80

06 B 0000007 50 2  33 15 62

09 C 0000010 95 60 35 93 76

When specifying non-consecutive fields from the left as key fields,

connect the key fields with the "@" symbol.

$ join0 key=3@1 master tran > data

Example 3 Using the "+ng" option

Selects the records where the key field does not match "master".

Records that match the key field are output to standard output.

Records that do not match are sent to standard error.

$ join0 +ng key=<key> <master> <tran> > ok 2> ng

(Master Field: master)

$ cat master

0000003 Wilson_____ 26 F

0000005 Hawking____ 50 F

0000007 Newton_____ 42 F

0000010 Tesla______ 50 F

(Transaction File: grades)

$ cat grades

0000000 91 59 20 76 54

0000001 46 39 8  5 21

0000003 30 50 71 36 30

0000004 58 71 20 10 6

0000005 82 79 16 21 80

0000007 50 2  33 15 62

0000008 52 91 44 9  0

0000009 60 89 33 18 6

0000010 95 60 35 93 76

0000011 92 56 83 96 75

Output records from the grades file "grades" that match "master" and

that do not match "master" to stdout and stderr.

$ join0 +ng key=1 master grades > ok-data 2> ng-data

$ cat ok-data   # (Matched Data)

0000003 30 50 71 36 30

0000005 82 79 16 21 80

0000007 50 2  33 15 62

0000010 95 60 35 93 76

$ cat ng-data   # (Unmatched Data)

0000000 91 59 20 76 54

0000001 46 39 8  5 21

0000004 58 71 20 10 6

0000008 52 91 44 9  0

0000009 60 89 33 18 6

0000011 92 56 83 96 75

Example 4

By specifying the file name as "-" you can read the "master" or

"tran" file from standard input. (Also for join1 and join2.)

Also, if you omit the "-" for "tran" it will be read from standard

input.

$ cat master | join0 key=1 - tran

$ cat tran | join0 key=1 master -

$ cat tran | join0 key=1 master      # "-" can be omitted.

Note 1 "+ng" option (also for join1)

In order to pipe the unmatched data to the next command, use the

followng syntax.

$ join0 +ng key=1 master tran 2>&1 1> ok-data  | next command...

If you only want to output unmatched data, direct the matched data

to /dev/null.

$ join0 +ng key=1 master tran > /dev/null 2> ng-data

Note 2

join0 and join1 output the records in "tran" whose key field matches

master, but even after all records of master have been read, the

remaining records in tran are read to the end (read and discarded).

This is designed to avoid jamming the pipe.

$ cat bigfile | join0 key=1 master > ok-data