src/commands/simple/join.c

Go to the documentation of this file.

/* join - relation data base operator   Author:  Saeko Hirabayashi */

/* Written by Saeko Hirabayashi, 1989.
 * 1992-01-28 Modified by Kouichi Hirabayashi to add some POSIX1003.2 options.
 *
 * This a free program.
 */

#include <string.h>
#include <stdio.h>

#define MAXFLD  200             /* maximum # of fields to accept */

_PROTOTYPE(void main, (int argc, char **argv));
_PROTOTYPE(void error, (char *s, char *t));
_PROTOTYPE(void usage, (void));
_PROTOTYPE(void match, (void));
_PROTOTYPE(void f1_only, (void));
_PROTOTYPE(void f2_only, (void));
_PROTOTYPE(void output, (int flag));
_PROTOTYPE(void outfld, (int file));
_PROTOTYPE(void outputf, (int flag));
_PROTOTYPE(int compare, (void));
_PROTOTYPE(int get1, (void));
_PROTOTYPE(int get2, (int back));
_PROTOTYPE(int getrec, (int file));
_PROTOTYPE(int split, (int file));
_PROTOTYPE(int atoi, (char *str));
_PROTOTYPE(int exit, (int val));
_PROTOTYPE(FILE * efopen, (char *file, char *mode));
_PROTOTYPE(void (*outfun), (int file)); /* output func: output() or outputf()*/

#define F1      1
#define F2      2
#define SEP     (sep ? sep : ' ')

FILE *fp[2];                    /* file pointer for file1 and file2 */
long head;                      /* head of the current (same)key group of the
                                 * file2 */

char buf[2][BUFSIZ];            /* input buffer for file1 and file2 */
char *fld[2][MAXFLD];           /* field vector for file1 and file2 */
int nfld[2];                    /* # of fields for file1 and file2 */

int kpos[2];                    /* key field position for file1 and file2
                                 * (from 0) */
char oldkey[BUFSIZ];            /* previous key of the file1 */

struct {                        /* output list by -o option */
  int o_file;                   /* file #: 0 or 1 */
  int o_field;                  /* field #: 0, 1, 2, .. */
} olist[MAXFLD];
int nout;                       /* # of output filed */

int aflag;                      /* n for '-an': F1 or F2 or both */
int vflag;                      /* n for '-vn': F1 or F2 or both */
char *es;                       /* s for '-e s' */
char sep;                       /* c for -tc: filed separator */
char *cmd;                      /* name of this program */

void main(argc, argv)
int argc;
char **argv;
{
  register char *s;
  int c, i, j;

  cmd = argv[0];
  outfun = output;              /* default output form */

  while (--argc > 0 && (*++argv)[0] == '-' && (*argv)[1]) {
        /* "-" is a file name (stdin) */
        s = argv[0] + 1;
        if ((c = *s) == '-' && !s[1]) {
                ++argv;
                --argc;
                break;          /* -- */
        }
        if (*++s == '\0') {
                s = *++argv;
                --argc;
        }
        switch (c) {
            case 'a':           /* add unpairable line to output */
                vflag = 0;
                switch (*s) {
                    case '1':   aflag |= F1;    break;
                    case '2':   aflag |= F2;    break;
                    default:    aflag |= (F1 | F2);     break;
                }
                break;

            case 'e':           /* replace empty field by es */
                es = s;
                break;

            case 'j':           /* key field (obsolute) */
                c = *s++;
                if (*s == '\0') {
                        s = *++argv;
                        --argc;
                }

            case '1':           /* key field of file1 */
            case '2':           /* key field of file2 */
                i = atoi(s) - 1;

                switch (c) {
                    case '1':   kpos[0] = i;    break;
                    case '2':   kpos[1] = i;    break;
                    default:    kpos[0] = kpos[1] = i;
                                break;
                }
                break;

            case 'o':           /* specify output format */
                do {
                        i = j = 0;
                        sscanf(s, "%d.%d", &i, &j);
                        if (i < 1 || j < 1 || i > 2) usage();
                        olist[nout].o_file = i - 1;
                        olist[nout].o_field = j - 1;
                        nout++;
                        if ((s = strchr(s, ',')) != (char *) 0)
                                s++;
                        else {
                                s = *++argv;
                                --argc;
                        }
                } while (argc > 2 && *s != '-');
                ++argc;
                --argv;         /* compensation */
                outfun = outputf;
                break;

            case 't':           /* tab char */
                sep = *s;
                break;

            case 'v':           /* output unpairable line only */
                aflag = 0;
                switch (*s) {
                    case '1':   vflag |= F1;    break;
                    case '2':   vflag |= F2;    break;
                    default:    vflag |= (F1 | F2);     break;
                }
                break;

            default:    usage();
        }
  }
  if (argc != 2) usage();

  fp[0] = strcmp(argv[0], "-") ? efopen(argv[0], "r") : stdin;
  fp[1] = efopen(argv[1], "r");

  nfld[0] = get1();             /* read file1 */
  nfld[1] = get2(0);            /* read file2 */

  while (nfld[0] || nfld[1]) {
        if ((i = compare()) == 0)
                match();
        else if (i < 0)
                f1_only();
        else
                f2_only();
  }
  fflush(stdout);

  exit(0);
}

void usage()
{
  fprintf(stderr,
    "Usage: %s [-an|-vn] [-e str] [-o list] [-tc] [-1 f] [-2 f] file1 file2\n",
    cmd);
  exit(1);
}

int compare()
{                               /* compare key field */
  register int r;

  if (nfld[1] == 0)             /* file2 EOF */
        r = -1;
  else if (nfld[0] == 0)        /* file1 EOF */
        r = 1;
  else {
        if (nfld[0] <= kpos[0])
                error("missing key field in file1", (char *) 0);
        if (nfld[1] <= kpos[1])
                error("missing key field in file2", (char *) 0);

        r = strcmp(fld[0][kpos[0]], fld[1][kpos[1]]);
  }
  return r;
}

void match()
{
  long p;

  if (!vflag) (*outfun) (F1 | F2);

  p = ftell(fp[1]);
  nfld[1] = get2(0);            /* check key order */
  if (nfld[1] == 0 || strcmp(fld[0][kpos[0]], fld[1][kpos[1]])) {
        nfld[0] = get1();
        if (strcmp(fld[0][kpos[0]], oldkey) == 0) {
                fseek(fp[1], head, 0);  /* re-do from head */
                nfld[1] = get2(1);      /* don't check key order */
        } else
                head = p;       /* mark here */
  }
}

void f1_only()
{
  if ((aflag & F1) || (vflag & F1)) (*outfun) (F1);
  nfld[0] = get1();
}

void f2_only()
{
  if ((aflag & F2) || (vflag & F2)) (*outfun) (F2);
  head = ftell(fp[1]);          /* mark */
  nfld[1] = get2(0);            /* check key order */
}

void output(f)
{                               /* default output form */
  if (f & F1)
        fputs(fld[0][kpos[0]], stdout);
  else
        fputs(fld[1][kpos[1]], stdout);
  if (f & F1) outfld(0);
  if (f & F2) outfld(1);
  fputc('\n', stdout);
}

void outfld(file)
{                               /* output all fields except key_field */
  register int i;
  int k, n;

  k = kpos[file];
  n = nfld[file];
  for (i = 0; i < n; i++)
        if (i != k) {
                fputc(SEP, stdout);
                fputs(fld[file][i], stdout);
        }
}

void outputf(f)
{                               /* output by '-o list' */
  int i, j, k;
  register char *s;

  for (i = k = 0; i < nout; i++) {
        j = olist[i].o_file;
        if ((f & (j + 1)) && (olist[i].o_field < nfld[j]))
                s = fld[j][olist[i].o_field];
        else
                s = es;
        if (s) {
                if (k++) fputc(SEP, stdout);
                fputs(s, stdout);
        }
  }
  fputc('\n', stdout);
}

int get1()
{                               /* read file1 */
  int r;
  static char oldkey1[BUFSIZ];

  if (fld[0][kpos[0]]) {
        strcpy(oldkey, fld[0][kpos[0]]);  /* save previous key for control */
  }
  r = getrec(0);

  if (r) {
        if (strcmp(oldkey1, fld[0][kpos[0]]) > 0)
              error("file1 is not sorted", (char *) 0);
        strcpy(oldkey1, fld[0][kpos[0]]);  /* save prev key for sort check */
  }
  return r;
}

int get2(back)
{                               /* read file2 */
  static char oldkey2[BUFSIZ];
  int r;

  r = getrec(1);

  if (r) {
        if (!back && strcmp(oldkey2, fld[1][kpos[1]]) > 0)
              error("file2 is not sorted", (char *) 0);
        strcpy(oldkey2, fld[1][kpos[1]]);  /* save prev key for sort check */
  }
  return r;
}

int getrec(file)
{                               /* read one line to split it */
  if (fgets(buf[file], BUFSIZ, fp[file]) == (char *) 0)
        *buf[file] = '\0';
  else if (*buf[file] == '\n' || *buf[file] == '\r')
        error("null line in file%s", file ? "1" : "0");

  return split(file);
}

int split(file)
{                               /* setup fields */
  register int n;
  register char *s, *t;

  for (n = 0, s = buf[file]; *s && *s != '\n' && *s != '\r';) {
        if (sep) {
                for (t = s; *s && *s != sep && *s != '\n' && *s != '\r'; s++);
        } else {
                while (*s == ' ' || *s == '\t')
                        s++;    /* skip leading white space */
                for (t = s; *s && *s != ' ' && *s != '\t'
                     && *s != '\n' && *s != '\r'; s++);
                /* We will treat trailing white space as NULL field */
        }
        if (*s) *s++ = '\0';
        fld[file][n++] = t;
        if (n == MAXFLD) error("too many filed in file%s", file ? "1" : "0");
  }
  fld[file][n] = (char *) 0;

  return n;
}

FILE *efopen(file, mode)
char *file, *mode;
{
  FILE *fp;

  if ((fp = fopen(file, mode)) == (FILE *) 0) error("can't open %s", file);

  return fp;
}

void error(s, t)
char *s, *t;
{
  fprintf(stderr, "%s: ", cmd);
  fprintf(stderr, s, t);
  fprintf(stderr, "\n");

  exit(1);
}

---