query macro

output.js

from t in transactions
  where t.x == 3 / 4 * 2 and z > 10
  select { t.x * 3 }


// Output:

({
  table: "transactions",
  binding: "t",
  where: {
    op: "and",
    left: {
      op: "==",
      left: {
        op: ".",
        left: "t",
        right: "x"
      },
      right: {
        op: "*",
        left: {
          op: "/",
          left: "3",
          right: "4"
        },
        right: "2"
      }
    },
    right: {
      op: ">",
      left: "z",
      right: "10"
    }
  },
  select: [{
    op: "*",
    left: {
      op: ".",
      left: "t",
      right: "x"
    },
    right: "3"
  }]
});

query-utils.js

#lang "sweet.js";

export var isDone = function(ctx) {
  const marker = ctx.mark();
  const next = ctx.next();
  ctx.reset(marker);
  return next.done;
}

export var matchNext = function(ctx, names) {
  const marker = ctx.mark();
  const next = ctx.next();
  ctx.reset(marker);
  return !next.done && names.includes(next.value.val());
}

export var parseExpression = function(ctx, s, makeSyntax) {
  const binaryOps = ["or", "and", "==", ">", "<", "-", "+", "*", "/", "."];

  function readBinaryOp(op) {
    const precIdx = binaryOps.indexOf(op);
    const isLast = precIdx === binaryOps.length - 1;
    const readNext = () => {
      if(isLast) {
        return s.fromString("" + ctx.next().value.val());
      }
      return readBinaryOp(binaryOps[precIdx + 1]);
    }
    const left = readNext();

    while(matchNext(ctx, [op])) {
      ctx.next();
      const right = readNext();
      left = makeSyntax(s.fromString(op), left, right);
    }

    return left;
  }

  function read() {
    return readBinaryOp(binaryOps[0]);
  }

  return read();
}

query.js

import { matchNext, parseExpression, isDone } from "./query-utils.js" for syntax;

syntax select = function(ctx) {
  const inner = ctx.next().value.inner();
  let res = #``;
  const s = #`dummy`.get(0);

  while(!isDone(inner)) {
    res = res.concat(parseExpression(inner, s, (op, left, right) => {
      return #`({ op: ${op}, left: ${left}, right: ${right} })`;
    }));

    // Consume ","
    if(inner.next().value) {
      res = res.concat(#`,`);
    }
  }

  const n = s.fromBrackets(res);
  return #`${n}`;
}

syntax from = function(ctx) {
  const binding = ctx.next().value;
  // eat "in"
  ctx.next();
  const table = ctx.next().value;
  const s = #`dummy`.get(0);

  let where = s.fromNull(), select = s.fromNull();

  while(1) {
    if(matchNext(ctx, ["where"])) {
      ctx.next();
      where = parseExpression(ctx, s, (op, left, right) => {
        return #`({ op: ${op}, left: ${left}, right: ${right} })`;
      })
    }
    else if(matchNext(ctx, ["select"])) {
      select = ctx.expand("expr").value;
    }
    else if(matchNext(ctx, ["join"])) {
      join = ctx.expand("expr").value;
    }
    else {
      break;
    }
  }

  const x = #`{ table: s.fromString(table.val()) }`;

  return #`({
    table: ${s.fromString(table.val())}
    binding: ${s.fromString(binding.val())}
    where: ${where},
    select: ${select}
  })`;
}