xql.js

// xql.js <https://github.com/jsstuff/xql>
(function($export, $as) {
"use strict";

/**
 * Root namespace.
 *
 * @namespace
 * @alias xql
 */
const xql = $export[$as] = {};

// ============================================================================
// [Public Constants]
// ============================================================================

/**
 * Version string.
 *
 * @alias xql.misc.VERSION
 */
const VERSION = "1.4.12";

/**
 * Identifier's quote style.
 *
 * @alias xql.QuoteStyle
 */
const QuoteStyle = Object.freeze({
  Double         : 0,          // Double quotes, for example "identifier".
  Grave          : 1,          // Grave quotes, for example `identifier`.
  Brackets       : 2           // Brackets, for example [identifier].
});
xql.QuoteStyle = QuoteStyle;

/**
 * Node flags.
 *
 * @alias xql.NodeFlags
 */
const NodeFlags = Object.freeze({
  Immutable      : 0x00000001, // Node is immutable (cannot be changed).
  Not            : 0x00000002, // Expression is negated (NOT).
  Ascending      : 0x00000010, // Sort ascending (ASC).
  Descending     : 0x00000020, // Sort descending (DESC).
  NullsFirst     : 0x00000040, // Sort nulls first (NULLS FIRST).
  NullsLast      : 0x00000080, // Sort nulls last (NULLS LAST).
  All            : 0x00000100, // ALL flag.
  Distinct       : 0x00000200, // DISTINCT flag.
  Statement      : 0x10000000  // This node represents a statement (like SELECT, UPDATE, etc).
});
xql.NodeFlags = NodeFlags;

/**
 * Operator and function flags.
 *
 * @alias xql.OpFlags
 */
const OpFlags = Object.freeze({
  Unary          : 0x00000001, // Unary operator (has one child node - `value`).
  Binary         : 0x00000002, // Binary operator (has two child nodes - `left` and `right`).
  Function       : 0x00000004, // Function (has arguments).
  Aggregate      : 0x00000008, // Function is an aggregate.
  Void           : 0x00000010, // Has no return value.
  LeftValues     : 0x00000100, // Operator expects left  values as (a, b[, ...]).
  RightValues    : 0x00000200, // Operator expects right values as (a, b[, ...]).
  SpaceSeparate  : 0x00000400  // Separate the function or operator by spaces before and after.
});
xql.OpFlags = OpFlags;

// ============================================================================
// [Internal Constants]
// ============================================================================

// Empty object/array used as an replacement for null/undefined in some cases.
const NoObject = Object.freeze(Object.create(null));
const NoArray = Object.freeze([]);

// Aliases that we use in xql.js source code.
const NF = NodeFlags;
const OF = OpFlags;

// Map of identifiers that are not escaped.
const IdentifierMap = { "*": true };

const StatementToOutputKeywordMap = Object.freeze({
  "INSERT": "INSERTED",
  "UPDATE": "UPDATED",
  "DELETE": "DELETED"
});

// Map of strings which can be implicitly casted to `TRUE` or `FALSE`.
const BoolMap = (function() {
  const map = {
    "0"            : false,
    "f"            : false,
    "false"        : false,
    "n"            : false,
    "no"           : false,
    "off"          : false,
    "1"            : true,
    "t"            : true,
    "true"         : true,
    "y"            : true,
    "yes"          : true,
    "on"           : true
  };
  Object.keys(map).forEach(function(key) { map[key.toUpperCase()] = map[key]; });
  return Object.freeze(map);
})();

const DateFieldMap = {
  "CENTURY"        : true,
  "DAY"            : true,
  "DECADE"         : true,
  "DOW"            : true,
  "DOY"            : true,
  "EPOCH"          : true,
  "HOUR"           : true,
  "ISODOW"         : true,
  "ISOYEAR"        : true,
  "MICROSECONDS"   : true,
  "MILLENIUM"      : true,
  "MILLISECONDS"   : true,
  "MINUTE"         : true,
  "MONTH"          : true,
  "QUARTER"        : true,
  "SECOND"         : true,
  "TIMEZONE"       : true,
  "TIMEZONE_HOUR"  : true,
  "TIMEZONE_MINUTE": true,
  "WEEK"           : true,
  "YEAR"           : true
};

const TypeMap = {
  "bool"           : "boolean",
  "boolean"        : "boolean",

  "bigint"         : "integer",
  "int"            : "integer",
  "integer"        : "integer",
  "smallint"       : "integer",

  "real"           : "number",
  "float"          : "number",
  "number"         : "number",
  "numeric"        : "number",

  "char"           : "string",
  "varchar"        : "string",
  "string"         : "string",
  "text"           : "string",

  "array"          : "array",
  "json"           : "json",
  "jsonb"          : "json",
  "object"         : "json",
  "raw"            : "raw",

  "values"         : "values",
  "date"           : "date",
  "time"           : "time",
  "timestamp"      : "timestamp",
  "timestamptz"    : "timestamptz",
  "interval"       : "interval"
};
Object.keys(TypeMap).forEach(function(key) {
  TypeMap[key.toUpperCase()] = TypeMap[key];
});

// Sort direction enum value from string.
const SortDirection = Object.freeze({
  ""             : 0,
  "0"            : 0,
  "1"            : NF.Ascending,
  "-1"           : NF.Descending,
  "ASC"          : NF.Ascending,
  "DESC"         : NF.Descending
});

// Sort nulls enum value from string.
const SortNulls = Object.freeze({
  "NULLS FIRST"  : NF.NullsFirst,
  "NULLS LAST"   : NF.NullsLast
});

// ============================================================================
// [Regular Expressions]
// ============================================================================

// Check for new line characters.
const reNewLine = /\n/g;

// Check for grave (`) quotes.
const reGraveQuotes = /`/g;

// Check for double (") quotes.
const reDoubleQuotes = /\"/g;

// Check for [] brackets.
const reBrackets = /\[\]/g;

// Check for '.' or '\0' characters.
const reDotOrNull = /[\.\x00]/g;

// Check for a well-formatted int with optional '-' sign.
const reInteger = /^-?\d+$/;

// Checks if a string is a well formatted integer or floating point number, also
// accepts scientific notation "E[+-]?xxx" and NaN/Infinity.
const reNumber = /^(NaN|-?Infinity|^-?((\d+\.?|\d*\.\d+)([eE][-+]?\d+)?))$/;

// Check for an UPPERCASE function name (no spaces).
const reUpperFunctionName = /^[A-Z_][A-Z_0-9]*$/;

// Check for an UPPERCASE operator name (can contain spaces between words).
const reUpperOperatorName = /^[A-Z_][A-Z_0-9 ]*(?: [A-Z_][A-Z_0-9 ]*)*$/;

// ============================================================================
// [Internal Functions]
// ============================================================================

// Always returns false, used internally for browser support.
function returnFalse() { return false; }

// Global shorthands.
const hasOwn   = Object.prototype.hasOwnProperty;
const slice    = Array.prototype.slice;

const isArray  = Array.isArray;
const isBuffer = typeof Buffer === "function" ? Buffer.isBuffer : returnFalse;

const deprecated = (function() {
  const map = Object.create(null);;

  return function(message) {
    if (message in map)
      return;

    map[message] = true;
    console.log(message);
  }
})();

function blobToHex(blob) {
  return blob.toString("hex");
}

function alias(classobj, spec) {
  const p = classobj.prototype;
  for (var member in spec)
    p[member] = p[spec[member]];
  return classobj;
}

// ============================================================================
// [xql.OpInfo]
// ============================================================================

/**
 * Operator and function information.
 *
 * @alias xml.OpInfo
 */
const OpInfo = new class OpInfo {
  constructor() {
    this._map = Object.create(null);
  }

  get(name) {
    const map = this._map;
    return name && hasOwn.call(map, name) ? map[name] : null;
  }

  add(info) {
    this._addInternal(info.name, info);
    if (info.nameNot) {
      const infoNot = Object.assign({}, info);
      infoNot.nodeFlags = NF.Not;
      this._addInternal(info.nameNot, infoNot);
    }
    return this;
  }

  _addInternal(key, info) {
    this._map[key] = info;
    const alias = key.replace(/ /g, "_");
    if (alias !== key)
      this._map[alias] = info;
  }

  addAlias(a, b) {
    this._map[a] = this._map[b];
    return this;
  }

  addNegation(a, b) {
    const aInfo = this._map[a];
    const bInfo = this._map[b];

    aInfo.not = bInfo;
    bInfo.not = aInfo;
    return this;
  }

  all() {
    return this._map;
  }

  forEach(cb, thisArg) {
    const map = this._map;
    for (var k in map)
      cb.call(thisArg, k, map[k]);
    return this;
  }
};
xql.OpInfo = OpInfo;

// ============================================================================
// [xql.error]
// ============================================================================

/**
 * Namespace which provides classes that represent errors thrown as exceptions.
 *
 * @namespace
 * @alias xql.error
 */
const xql$error = xql.error = {};

/**
 * Error thrown if data is wrong.
 *
 * @param message Error message.
 *
 * @alias xql.error.ValueError
 */
class ValueError extends Error {
  constructor(message) {
    super(message);
    this.name = "ValueError";
    this.message = message;
  }
}
xql$error.ValueError = ValueError;

/**
 * Error thrown if SQL construct is wrong and cannot be compiled.
 *
 * @param message Error message.
 *
 * @alias xql.error.CompileError
 */
class CompileError extends Error {
  constructor(message) {
    super(message);
    this.name = "CompileError";
    this.message = message;
  }
}
xql$error.CompileError = CompileError;

function throwTypeError(message) { throw new TypeError(message); }
function throwValueError(message) { throw new ValueError(message); }
function throwCompileError(message) { throw new CompileError(message); }

// ============================================================================
// [xql.misc]
// ============================================================================

/**
 * Miscellaneous namespace.
 *
 * @namespace
 * @alias xql.misc
 */
const xql$misc = xql.misc = {};

/**
 * Version information in a "major.minor.patch" form.
 *
 * Note: Version information has been put into the `xql.misc` namespace to
 * prevent a possible clashing with SQL builder's interface exported in the
 * root namespace.
 *
 * @alias xql.misc.VERSION
 */
xql$misc.VERSION = VERSION;

/**
 * Get a type of the `value` as a string. This function extends a javascript
 * `typeof` operator with "array", "buffer", "null" and "undefined". It's used
 * for debugging and error handling purposes to enhance error messages.
 *
 * @param {*} value
 * @return {string}
 *
 * @function xql.misc.typeOf
 */
function typeOf(value) {
  if (value == null)
    return value === null ? "null" : "undefined";

  if (typeof value !== "object")
    return typeof value;

  if (isArray(value))
    return "array";

  if (isBuffer(value))
    return "buffer";

  if (value instanceof Node)
    return value._type || "Node";

  return "object";
}
xql$misc.typeOf = typeOf;

function parseVersion(s) {
  const parts = s.split(".");
  const re = /^[0-9]+$/g;

  var major = 0;
  var minor = 0;
  var patch = 0;

  for (var i = 0, len = Math.min(parts.length, 3); i < len; i++) {
    var part = parts[i];
    if (!re.test(part))
      break;

    var n = parseInt(part);
    switch (i) {
      case 0: major = n; break;
      case 1: minor = n; break;
      case 2: patch = n; break;
    }
  }

  return {
    major: major,
    minor: minor,
    patch: patch
  }
}

function indent(s, indentation) {
  return (s && indentation) ? indentation + s.replace(reNewLine, "\n" + indentation) : s;
}
xql$misc.indent = indent;

// ============================================================================
// [xql.dialect]
// ============================================================================

/**
 * Database dialects namespace.
 *
 * @namespace
 * @alias xql.dialect
 */
const xql$dialect = xql.dialect = Object.create(null);

/**
 * Mapping from a dialect string into a dialect `Context` class.
 *
 * @var xql.dialect.registry
 */
const xql$dialect$registry = Object.create(null);
xql$dialect.registry = xql$dialect$registry;

/**
 * Checks whether the `dialect` exists in the global registry.
 *
 * @param {string} dialect A name of the dialect (always lowercase).
 * @return {boolean}
 *
 * @function xql.dialect.has
 */
function xql$dialect$has(dialect) {
  return hasOwn.call(xql$dialect$registry, dialect);
}
xql$dialect.has = xql$dialect$has;

/**
 * Checks whether the `dialect` exists in the global registry.
 *
 * @param {string} dialect A name of the dialect (always lowercase).
 * @return {Context} A dialect Context (if found) or null.
 *
 * @function xql.dialect.get
 */
function xql$dialect$get(dialect) {
  return hasOwn.call(xql$dialect$registry, dialect) ? xql$dialect$registry[dialect] : null;
}
xql$dialect.get = xql$dialect$get;

/**
 * Adds a new dialect to the global registry.
 *
 * @param {string} dialect A name of the dialect (always lowercase).
 * @param {function} classobj A `Context` class object (not instantiated).
 *
 * @function xql.dialect.add
 */
function xql$dialect$add(dialect, classobj) {
  xql$dialect$registry[dialect] = classobj;
}
xql$dialect.add = xql$dialect$add;

/**
 * Constructs a new `Context` for a given options.
 *
 * @param {object} options Context options.
 * @param {string} options.dialect Database dialect (must be registered).
 * @return {Context} Instantiated `Context`.
 *
 * @function xql.dialect.newContext
 */
function $xql$dialect$newContext(options) {
  if (typeof options !== "object" || options === null)
    throwTypeError("xql.dialect.newContext() - Options must be Object");

  const dialect = options.dialect;
  if (typeof dialect !== "string")
    throwTypeError("xql.dialect.newContext() - Options must have a dialect key");

  if (!hasOwn.call(xql$dialect$registry, dialect))
    throwTypeError("xql.dialect.newContext() - Unknown dialect '" + dialect + "'");

  const classobj = xql$dialect$registry[dialect];
  return new classobj(options);
}
xql$dialect.newContext = $xql$dialect$newContext;

// ============================================================================
// [xql.dialect.Context]
// ============================================================================

function fnEscapeBrackets(s) {
  return s.charCodeAt(0) === 91 ? "[[" : "]]";
}

/**
 * Database dialect context that provides an interface that query builders can
 * use to build a dialect-specific queries. The context itself provides some
 * dialect-agnostic functionality that is shared between multiple dialect
 * implementations.
 *
 * It's essential to call `_updateInternalData()` in your own constructor when
 * extending `Context` to implement your own database dialect.
 *
 * @param {string} dialect Database dialect the context is using.
 * @param {object} options Context options.
 *
 * @alias xql.dialect.Context
 */
class Context {
  constructor(dialect, options) {
    this.dialect = dialect;

    // Context configuration.
    this.pretty = options.pretty ? true : false;
    this.indentation = options.indentation || 2;

    // Dialect version (no version specified is the default).
    this.version = options.version ? parseVersion(options.version) : {
      major: 0,
      minor: 0,
      patch: 0
    };

    // Dialect features (these are modified by a dialect-specific `Context`).
    this.features = {
      quoteStyle       : QuoteStyle.Double, // The default SQL quotes are "".
      nativeBoolean    : false,              // Supports BOOLEAN.
      nativeRange      : false,              // Supports RANGE.
      nativeArray      : false,              // Supports ARRAY.
      nativeJSON       : false,              // Supports JSON.
      nativeJSONB      : false,              // Supports JSONB.
      nativeHSTORE     : false,              // Supports HSTORE.
      nullsOrdering    : false,              // Supports NULLS FIRST and NULLS LAST.
      nullsSortBottom  : false,              // NULLs are sorted last by default.
      defaultValues    : false,              // Supports DEFAULT keyword in VALUES(...).
      selectTopN       : false,              // Supports Top-N queries.
      leastGreatest    : "LEAST|GREATEST",   // Supports GREATEST/LEAST functions.
      returning        : "",                 // If RETURNING or OUTPUT is supported.
      specialNumbers   : false               // No special numbers by default.
    };

    // Computed properties based on configuration and dialect features. These
    // require `_updateInternalData()` to be called after one or more property
    // is changed.
    this._DB_TRUE        = "";   // Dialect-specific TRUE value.
    this._DB_FALSE       = "";   // Dialect-specific FALSE value.
    this._DB_NAN         = "";   // Dialect-specific NaN value.
    this._DB_POS_INF     = "";   // Dialect-specific Positive infinity value.
    this._DB_NEG_INF     = "";   // Dialect-specific Negative infinity value.
    this._DB_IDENT_OPEN  = "";   // Escape character inserted before SQL identifier.
    this._DB_IDENT_CLOSE = "";   // Escape character inserted after SQL identifier.

    this._STR_OPT_NL     = "";   // Optional newline (will either be "\n" or "").
    this._STR_BLANK      = "";   // Space or newline (will either be "\n" or " ").
    this._STR_COMMA      = "";   // Comma separator, either ", " or ",\n" (pretty).
    this._STR_INDENT     = "";   // Indentation string.
    this._STR_CONCAT     = "";   // Concatenation string, equals to `space + _STR_INDENT`.

    // Regular expression that checks if the identifier needs escaping.
    this._RE_IDENT_CHECK = null;

    // Functions that can be updated based on the settings and database dialect.
    this.indent = null;
    this.concat = null;
    this.concatNoSpace = null;

    this._wrap = null;
    this._compileInsert = null;
    this._compileReturning = null;
    this._compileOffsetLimit = null;
  }

  /**
   * Set the version of the dialect to the given `version`.
   *
   * @param {string} version Version string as "major.minor.patch". The string
   * can omit any version part if not used, gratefully accepting "major.minor"
   * and/or "major" only. If any version part that is omitted will be set to 0.
   *
   * @return {this}
   */
  setVersion(version) {
    this.version = parseVersion(version);
    this._updateInternalData();
    return this;
  }

  /**
   * Compiles the given expression or statement `q`.
   *
   * @param {string|Node} q Expression or statement to compile, can be either
   * string or `xql.Node`.
   *
   * @return {string} Compiled SQL expression or statement as a string.
   *
   * @throws {TypeError} If `q` is an object that is not compatible with `xql.Node`.
   */
  compile(q) {
    if (typeof q === "string")
      return q;

    if (q && typeof q.compileStatement === "function")
      return q.compileStatement(this);

    throwTypeError("xql.Context.compile() - Invalid argument");
  }

  _compile(something, valueType) {
    if (something instanceof Node)
      return something.compileNode(this);
    else
      return this.escapeValue(something, valueType);
  }

  /**
   * Escapes a single or multiple SQL identifier(s).
   *
   * @param {string|string[]} ident Idenfifier or array of identifiers to escape.
   * @return {string} Escaped identifier(s).
   */
  escapeIdentifier(ident) {
    var input = "";
    var output = "";

    var i = 0;
    var len = 1;

    if (isArray(ident)) {
      len = ident.length;
      if (len > 0)
        input = ident[0];
    }
    else {
      input = ident;
    }

    const re = this._RE_IDENT_CHECK;
    for (;;) {
      // Apply escaping to all parts of the identifier (if any).
      for (;;) {
        // Ignore undefined/null parts of the input.
        if (input == null)
          break;

        var m = input.search(re);
        var p = input;

        // Multiple arguments are joined by using ".".
        if (output) output += ".";

        if (m !== -1) {
          var c = input.charCodeAt(m);

          // `.` === 46.
          if (c === 46) {
            // Dot separator, that's fine
            p = input.substr(0, m);
          }
          else {
            // NULL character in identifier is not allowed.
            if (c === 0)
              throwCompileError("Identifier can't contain NULL character");

            // Character that needs escaping. In this case we repeat the
            // search by using simpler regular expression and then pass
            // the whole string to a function that will properly escape
            // it (as this function is very generic and can handle all
            // dialects easily).
            m = input.search(reDotOrNull);
            if (m !== -1) {
              c = input.charCodeAt(m);
              if (c === 46)
                p = input.substr(0, m);
              else
                throwCompileError("Identifier can't contain NULL character");
            }
            p = this.escapeIdentifierImpl(p);
          }
        }

        if (hasOwn.call(IdentifierMap, p))
          output += p;
        else
          output += this._DB_IDENT_OPEN + p + this._DB_IDENT_CLOSE;

        if (m === -1)
          break;
        input = input.substr(m + 1);
      }

      if (++i >= len)
        break;
      input = ident[i];
    }

    // Return an empty identifier (allowed) in case the output is empty.
    return output ? output : this._DB_IDENT_OPEN + this._DB_IDENT_CLOSE;
  }

  /**
   * Escapes a single identifier.
   *
   * Please do not use this function directly. It's called by `escapeIdentifier`
   * to escape an identifier (or some part of it) in a dialect-specific way.
   *
   * @param {string} ident Identifier to escape, which should be already
   *   checked (for example it shouldn't contain NULL characters).
   * @return {string} Escaped identifier.
   */
  escapeIdentifierImpl(ident) {
    // NOTE: This function is only called when `ident` contains one or more
    // characters to escape. It doesn't have to be super fast as it involes
    // regexp search & replace anyway. This is the main reason it's generally
    // not reimplemented by a dialect-specific implementation as it won't
    // bring any performance gain.
    const qs = this.features.quoteStyle;

    if (qs == QuoteStyle.Double  ) return ident.replace(reDoubleQuotes, "\"\"");
    if (qs == QuoteStyle.Grave   ) return ident.replace(reGraveQuotes, "``");
    if (qs == QuoteStyle.Brackets) return ident.replace(reBrackets, fnEscapeBrackets);

    throwCompileError("Cannot escape identifier: Invalid 'features.quoteStyle' set");
  }

  /**
   * Escapes `value` so it can be inserted into a SQL query.
   *
   * The `value` can be any JS type that can be implicitly or explicitly
   * converted to SQL. The `explicitType` parameter can be used to force
   * the type explicitly in case of ambiguity.
   *
   * @param {*} value A value to escape.
   * @param {string} [explicitType] SQL type override
   * @return {string} Escaped `value` as string.
   */
  escapeValue(value, explicitType) {
    if (value instanceof Node)
      throwTypeError("Context.escapeValue() - Value cannot be node here, use '_compile()' instead");

    // Explicitly Defined Type (`explicitType` is set)
    // -----------------------------------------------

    if (explicitType) {
      var type = TypeMap[explicitType];
      if (!type)
        throwValueError("Unknown explicit type '" + explicitType + "'");

      switch (type) {
        case "boolean":
          if (value == null) return "NULL";

          if (typeof value === "boolean")
            return value === true ? this._DB_TRUE : this._DB_FALSE;

          if (typeof value === "string" && hasOwn.call(BoolMap, value))
            return BoolMap[value] === true ? this._DB_TRUE : this._DB_FALSE;

          if (typeof value === "number") {
            if (value === 0) return this._DB_FALSE;
            if (value === 1) return this._DB_TRUE;
            throwValueError("Couldn't convert 'number(" + value + ")' to 'boolean'");
          }

          // Will throw.
          break;

        case "integer":
          if (value == null) return "NULL";

          if (typeof value === "number") {
            if (!isFinite(value) || Math.floor(value) !== value)
              throwValueError("Couldn't convert 'number(" + value + ")' to 'integer'");
            return value.toString();
          }

          if (typeof value === "string") {
            if (!reInteger.test(value))
              throwValueError("Couldn't convert ill formatted 'string' to 'integer'");
            return value;
          }

          // Will throw.
          break;

        case "number":
          if (value == null) return "NULL";

          if (typeof value === "number")
            return this.escapeNumber(value);

          if (typeof value === "string") {
            if (!reNumber.test(value))
              throwValueError("Couldn't convert ill formatted 'string' to 'number'");
            return value;
          }

          // Will throw
          break;

        case "string":
          if (value == null) return "NULL";

          if (typeof value === "string")
            return this.escapeString(value);

          if (typeof value === "number" || typeof value === "boolean")
            return this.escapeString(value.toString());

          if (typeof value === "object")
            return this.escapeString(JSON.stringify(value));

          // Will throw.
          break;

        case "values":
          if (value == null) return "NULL";

          if (Array.isArray(value))
            return this.escapeValues(value, false);

          // Will throw.
          break;

        case "date":
        case "time":
        case "timestamp":
        case "timestamptz":
        case "interval":
          if (typeof value === "string") {
            return explicitType + " " + this.escapeString(value);
          }

          // Will throw.
          break;

        case "array":
          if (value == null) return "NULL";

          if (Array.isArray(value))
            return this.escapeArray(value, false);

          // Will throw.
          break;

        case "json":
        case "jsonb":
          // `undefined` maps to native DB `NULL` type while `null` maps to
          // JSON `null` type. This is the only way to distinguish between
          // these. `undefined` is disallowed by JSON anyway.
          if (value === undefined) return "NULL";
          return this.escapeJSON(value, type);

        case "raw":
          return value;
      }

      throwValueError("Couldn't convert '" + typeOf(value) + "' to '" + explicitType + "'");
    }

    // Implicitly Defined Type (deduced from `value`)
    // ----------------------------------------------

    // Check - `string`, `number` and `boolean`.
    //
    // These types are expected in most cases so they are checked first. All
    // other types require more processing to escape them properly anyway.
    if (typeof value === "string") return this.escapeString(value);
    if (typeof value === "number") return this.escapeNumber(value);
    if (typeof value === "boolean") return value === true ? this._DB_TRUE : this._DB_FALSE;

    // Check - `undefined` and `null`.
    //
    // Undefined implicitly converts to `NULL`.
    if (value == null) return "NULL";

    // Sanity.
    //
    // At this point the only expected type of value is `object`.
    if (typeof value !== "object")
      throwValueError("Unexpected implicit value type '" + (typeof value) + "'");

    // Node.
    //
    // All xql objects extend `Node`.
    if (value instanceof Node)
      return value.compileNode(this);

    // Check - Buffer (BLOB / BINARY).
    if (isBuffer(value))
      return this.escapeBuffer(value);

    // Check - Array (ARRAY).
    if (isArray(value))
      return this.escapeArray(value, false);

    return this.escapeJSON(value, "json");
  }

  /**
   * Escapes a number `value` into a SQL number.
   *
   * @param {number} value Number to escape.
   * @return {string} Escaped `value` as string.
   */
  escapeNumber(value) {
    if (!isFinite(value)) {
      var out = (value ===  Infinity) ? this._DB_POS_INF :
                (value === -Infinity) ? this._DB_NEG_INF : this._DB_NAN;

      if (out === "")
        throwValueError("Couldn't process a special number (Infinity/NaN)");
      return out;
    }

    return value.toString();
  }

  /**
   * Escapes a number `value` into a SQL string.
   *
   * @param {string} value A string to escape.
   * @return {string} Escaped `value` as string.
   *
   * @abstract
   */
  escapeString(value) {
    throwTypeError("Abstract method called");
  }

  /**
   * Escapes a buffer/blob `value` into a SQL buffer representation.
   *
   * @param {Buffer} value Buffer to escape.
   * @return {string} Escaped `value` as buffer.
   */
  escapeBuffer(value) {
    return "x'" + blobToHex(value) + "'";
  }

  /**
   * Escapes an array into SQL `VALUES` representation.
   *
   * @param {array} value Array to escape.
   * @return {string} Escaped `value` as SQL `VALUES`.
   */
  escapeValues(value) {
    var out = "";

    for (var i = 0, len = value.length; i < len; i++) {
      var element = value[i];
      if (out) out += ", ";

      if (isArray(element))
        out += this.escapeArray(element, false);
      else
        out += this._compile(element);
    }

    return "(" + out + ")";
  }

  /**
   * Escapes an array into a SQL ARRAY representation.
   *
   * By default it converts the array into a JSON-based string representation
   * to ensure compatibility with engines that don't support arrays natively.
   * However, some engines like PostgreSQL support arrays and will use proper
   * ARRAY escaping.
   *
   * @param {array} value Array to escape.
   * @param {boolean} nested Whether the array is nested in another array.
   *   Some dialects (like pgsql) need this information to properly escape the
   *   array.
   * @return {string} Escaped `value` as SQL-ARRAY or compatible.
   */
  escapeArray(value, nested) {
    return this.escapeString(JSON.stringify(value));
  }

  /**
   * Escapes a value into a SQL JSON representation.
   *
   * By default it converts the array into a JSON-based string representation
   * to ensure compatibility with engines that don't support JSON natively or
   * that have support for JSON by using string literals like PostgreSQL does.
   *
   * @param {*} value Value to escape.
   * @return {string} Escaped `value` as SQL-JSON.
   */
  escapeJSON(value, type) {
    return this.escapeString(JSON.stringify(value));
  }

  /**
   * Escapes a value (or compiles it if it's an expression) and surrounds it
   * with parentheses if it's an expression.
   *
   * The purpose of this function is to simplify generation of some expressions
   * where omitting sparentheses could cause SQL error due to operator precedence
   * or ambiguity.
   */
  escapeOrWrap(value) {
    const out = this._compile(value);

    if (value instanceof Node && !(value instanceof Value) && !(value instanceof Identifier))
      return "(" + out + ")";
    else
      return out;
  }

  /**
   * Substitutes `?` sequences or Postgres specific `$N` sequences in the `query`
   * string with `bindings` and returns a new string. The function automatically
   * detects the format of `query` string and checks if it's consistent (i.e. it
   * throws if `?` is used together with `$1`).
   *
   * This function knows how to recognize escaped identifiers and strings in the
   * query and skips content of these. For example for a given string `'?' ?`
   * only the second `?` would be considered and substituted.
   *
   * NOTE: Although the function understands SQL syntax, the function expects
   * well formed SQL query. The purpose is to substitute query parameters and
   * not performing expensive validation (that will be done by the server anyway).
   *
   * @param {string} query Query string to substitute (template).
   * @param {array} [bindings] Array of values to bind to `query`.
   * @return {string}
   *
   * @abstract
   */
  substitute(query, bindings) {
    throwTypeError("Abstract method called");
  }

  /**
   * Called whenever some property is changed to update all computed properties.
   *
   * @private
   */
  _updateInternalData() {
    const pretty = this.pretty;
    const f = this.features;
    const qs = f.quoteStyle;

    // Update everything sensitive to DB dialect and dialect-based options.
    this._DB_TRUE = f.nativeBoolean ? "TRUE"  : "1";
    this._DB_FALSE = f.nativeBoolean ? "FALSE" : "0";

    if (qs === QuoteStyle.Double) {
      this._DB_IDENT_OPEN = "\"";
      this._DB_IDENT_CLOSE = "\"";
      this._RE_IDENT_CHECK = /[\.\"\x00]/g;
    }

    if (qs === QuoteStyle.Grave) {
      this._DB_IDENT_OPEN = "`";
      this._DB_IDENT_CLOSE = "`";
      this._RE_IDENT_CHECK = /[\.\`\x00]/g;
    }

    if (qs === QuoteStyle.Brackets) {
      this._DB_IDENT_OPEN = "[";
      this._DB_IDENT_CLOSE = "]";
      this._RE_IDENT_CHECK = /[\.\[\]\x00]/g;
    }

    // Update members that are not DB dialect sensitive (pretty print).
    this._STR_OPT_NL = !pretty ? ""   : "\n";
    this._STR_BLANK  = !pretty ? " "  : "\n";
    this._STR_COMMA  = !pretty ? ", " : ",\n";
    this._STR_INDENT = !pretty ? ""   : " ".repeat(this.indentation);
    this._STR_CONCAT = !pretty ? " "  : this._STR_BLANK + this._STR_INDENT;

    // Update the implementation of the most important building functions.
    this.indent        = !pretty ? this._indent$none  : this._indent$pretty;
    this.concat        = !pretty ? this._concat$space : this._concat$pretty;
    this.concatNoSpace = !pretty ? this._concat$none  : this._concat$pretty;
    this._wrap         = !pretty ? this._wrap$simple  : this._wrap$pretty;

    this._compileInsert = !f.defaultValues ? this._compileInsert$noDefaults
                                           : this._compileInsert$useDefaults;

    switch (f.returning) {
      case ""         : this._compileReturning = this._compileReturning$NoImpl; break;
      case "RETURNING": this._compileReturning = this._compileReturning$Base; break;
      case "OUTPUT"   : this._compileReturning = this._compileReturning$Output; break;
      default:
        throwTypeError(`Invalid value '${f.returning}' in features.returning`);
    }

    this._compileOffsetLimit = !f.selectTopN ? this._compileOffsetLimit$Simple
                                             : this._compileOffsetLimit$TopN;
  }

  /**
   * Indents a given string `s` by the Context's indentation settings if pretty
   * print is enabled, otherwise does nothing.
   *
   * @param {string} s String to indent.
   * @return {string} Indented string if indentation is enabled or unchanged `s`.
   *
   * @function
   * @alias xql.dialect.Context.prototype.indent
   */
  _indent$none(s) {
    return s;
  }

  _indent$pretty(s) {
    var INDENT = this._STR_INDENT;
    return INDENT + s.replace(reNewLine, "\n" + INDENT);
  }

  /**
   * TODO: Change the name
   *
   * Called before a string `s` is concatenated into a SQL expression in a way
   * that may require a new line if pretty printing is enabled. It returns the
   * original string prefixed with a space or a line break and possibly indented.
   *
   * @param {string} s Input string to process.
   * @return {string} Possibly modified string.
   *
   * @function
   * @alias xql.dialect.Context.prototype.concat
   */
  _concat$none(s) {
    return s;
  }

  _concat$space(s) {
    return " " + s;
  }

  _concat$pretty(s) {
    var _STR_CONCAT = this._STR_CONCAT;
    return _STR_CONCAT + s.replace(reNewLine, _STR_CONCAT);
  }

  _wrap$simple(str) { return `(${str})`; }
  _wrap$pretty(str) { return "(" + indent(str + ")", " ").substr(1); }

  _compileValues(something) {
    if (something instanceof Node) {
      const body = something.compileNode(this);
      return body.startsWith("(") && body.endsWith(")") ? body : `(${body})`;
    }
    else if (Array.isArray(something)) {
      return this.escapeValues(something);
    }
    else {
      const body = this.escapeValue(something);
      return body.startsWith("(") && body.endsWith(")") ? body : `(${body})`;
    }
  }

  _compileUnaryNode(node) {
    var type = node._type;
    var out = this._compile(node._value);

    switch (type) {
      case "NOT":
        out = "NOT (" + out + ")";
        break;

      case "-":
        out = "-(" + out + ")";
        break;

      default:
        if (type)
          out = type + " " + out;
        break;
    }

    var alias = node._alias;
    if (alias)
      out += " AS " + this.escapeIdentifier(alias);

    return out;
  }

  _compileBinaryNode(node) {
    var type = node._type;
    var out = "";

    var keyword = "";

    var leftNode = node._left;
    var rightNode = node._right;
    var nodeFlags = node._flags;

    var left = "";
    var right = "";

    if (!type)
      throwCompileError("_compileBinaryNode.compileNode() - No operator specified");

    var opInfo = OpInfo.get(type);
    var opFlags = opInfo ? opInfo.opFlags : 0;

    if (opFlags & OpFlags.LeftValues)
      left = this._compileValues(leftNode);
    else
      left = this._compile(leftNode);

    if (opFlags & OpFlags.RightValues)
      right = this._compileValues(rightNode);
    else
      right = this._compile(rightNode);

    if (opInfo) {
      // Check if the right operand is `NULL` and convert the operator to `IS`
      // or `IS NOT` if necessary to be more conforming to the SQL standard.
      if (right === "NULL") {
        if (opInfo.name === "=") {
          opInfo = OpInfo.get("IS");
          opFlags = opInfo.opFlags;
        }
        else if (opInfo.name === "<>") {
          opInfo = OpInfo.get("IS");
          opFlags = opInfo.opFlags;
          nodeFlags |= NF.Not;
        }
      }

      keyword = opInfo.format;
      if (nodeFlags & NF.Not)
        keyword = opInfo.formatNot;
    }
    else {
      keyword = " " + type + " ";
    }

    if (leftNode instanceof Node && leftNode.mustWrap(this, node)) left = "(" + left + ")";
    if (rightNode instanceof Node && rightNode.mustWrap(this, node)) right = "(" + right + ")";

    out = left + keyword + right;

    var alias = node._alias;
    if (alias)
      out += " AS " + this.escapeIdentifier(alias);

    return out;
  }

  /**
   * Compiles a function (xql.node.Func).
   *
   * @param {xql.node.Func} node Function node.
   * @return {string} Compiled function.
   *
   * @private
   */
  _compileFuncNode(node) {
    const name = node._type;
    const info = OpInfo.get(name);

    // Check if the function is known and if it has specialized compiler.
    if (info !== null && info.compile !== null)
      return info.compile(this, node);
    else
      return this._compileFuncImpl(name, node._values, node._flags, node._alias);
  }

  _compileFuncImpl(name, args, flags, alias) {
    var out = "";

    for (var i = 0, len = args.length; i < len; i++) {
      const value = args[i];
      const compiled = this._compile(value);
      if (out)
        out += ", ";
      out += compiled;
    }

    // Compile `DISTINCT` if specified.
    if (flags & NF.Distinct)
      out = "DISTINCT " + out;

    // Form the function including an alias.
    return this._compileFuncAs(name + "(" + out + ")", alias, flags);
  }

  _compileFuncAs(body, alias) {
    return alias ? body + " AS " + this.escapeIdentifier(alias) : body;
  }

  _compileAs(exp, alias) {
    return alias ? "(" + exp +") AS " + this.escapeIdentifier(alias) : exp;
  }

  /**
   * Compiles SELECT statement.
   *
   * @param {xql.node.SelectStatement} node Select node.
   * @return {string} Compiled SELECT.
   *
   * @private
   */
  _compileSelect(node) {
    const BLANK = this._STR_BLANK;

    const with_ = node._with;
    const flags = node._flags;
    const offset = node._offset;
    const limit = node._limit;

    // Compile `WITH ...`
    var out = "";
    if (with_.length !== 0)
      out = this._compileWithClause(with_) + BLANK;

    // Compile `SELECT [ALL|DISTINCT]`
    //
    // Use `*` if  fields are not used.
    out += "SELECT";
    if (flags & NF.Distinct) {
      const distinct = node._distinct;
      if (isArray(distinct) && distinct.length)
        out += this.concat("DISTINCT ON (" + this.concatNoSpace(this._compileFields(distinct) + ")"));
      else
        out += " DISTINCT";
    }

    // Compile `[*|fields]`
    //
    // Note, `*` is only used if there are no columns specified.
    const cols = node._fieldsOrReturning;
    out += this.concat(cols && cols.length ? this._compileFields(cols) : "*");

    // Compile `FROM table[, table[, ...]]` or `FROM table JOIN table [, JOIN ...]`.
    const from = node._fromOrUsing;
    if (from)
      out += BLANK + "FROM" + this.concat(this._compileFromOrUsing(from));

    // Compile `WHERE ...`.
    const where = node._where;
    if (where && where._values.length)
      out += BLANK + "WHERE" + this.concat(this._compileWhereOrHaving(where));

    // Compile `GROUP BY ...`.
    const groupBy = node._groupBy;
    if (groupBy && groupBy.length)
      out += BLANK + "GROUP BY" + this.concat(this._compileGroupBy(groupBy));

    // Compile `HAVING ...`.
    const having = node._having;
    if (having && having._values.length)
      out += BLANK + "HAVING" + this.concat(this._compileWhereOrHaving(having));

    // TODO: Compile `WINDOW ...`.

    // Compile `ORDER BY ...`.
    const orderBy = node._orderBy;
    if (orderBy && orderBy.length)
      out += BLANK + "ORDER BY" + this.concat(this._compileOrderBy(orderBy));

    // Compile `OFFSET ...` / `LIMIT ...`.
    if (offset || limit)
      out += BLANK + this._compileOffsetLimit(offset, limit);

    // TODO: Compile `FETCH ...`.
    // TODO: Compile `FOR ...`.

    // Compile `(...) AS identifier`.
    const alias = node._alias;
    if (alias)
      out = this._wrap(out) + " AS " + this.escapeIdentifier(alias);

    return out;
  }

  /**
   * Compiles INSERT statement that can contain DEFAULT in VALUES().
   *
   * @private
   */
  _compileInsert$useDefaults(node) {
    const BLANK = this._STR_BLANK;
    const features = this.features;

    const with_ = node._with;
    const table = node._table;
    const objects = node._values;
    const columns = node._columns;
    const returning = node._fieldsOrReturning || NoArray;
    const typeMapping = node._typeMapping || NoObject;

    // Compile `INSERT INTO table (...)`.
    if (!table)
      throwCompileError("InsertStatement.compileNode() - Table not defined");

    const prefix = (this.pretty ? this._STR_CONCAT : " ");
    const into = typeof table === "string" ? this.escapeIdentifier(table)
                                           : table.compileNode(this);

    var k;
    var cols = "";

    // Compile columns that follow "INSERT INTO ..."
    for (k in columns) {
      if (cols) cols += ", ";
      cols += this.escapeIdentifier(k);
    }

    // Compile `WITH ...`
    var out = "";
    if (with_.length !== 0)
      out = this._compileWithClause(with_) + BLANK;

    // Compile values.
    out += "INSERT INTO";
    if (cols) {
      out += this.concat(into + " (" + cols + ")") + BLANK + "VALUES";

      for (var i = 0, len = objects.length; i < len; i++) {
        const object = objects[i];

        var vals = "";
        for (k in columns) {
          if (vals) vals += ", ";
          if (hasOwn.call(object, k))
            vals += this._compile(object[k], typeMapping[k]);
          else
            vals += "DEFAULT";
        }

        if (i !== 0) out += ",";
        out += prefix + "(" + vals + ")";
      }
    }
    else {
      var str = "";
      for (var i = 0, len = objects.length; i < len; i++) {
        if (i !== 0) str += ",";
        str += BLANK + "DEFAULT VALUES";
      }
      out += this.concat(into + str);
    }

    // Compile `RETURNING ...` or `OUTPUT ...`.
    if (features.returning && returning.length !== 0)
      out += BLANK + this._compileReturning(returning, "INSERT");

    return out;
  }

  /**
   * Compiles INSERT statement that cannot contain DEFAULT in VALUES().
   *
   * @private
   */
  _compileInsert$noDefaults(node) {
    const BLANK = this._STR_BLANK;
    const features = this.features;

    const with_ = node._with;
    const table = node._table;
    const objects = node._values;
    const returning = node._fieldsOrReturning || NoArray;
    const typeMapping = node._typeMapping || NoObject;

    // Compile `INSERT INTO table (...)`.
    if (!table)
      throwCompileError("InsertStatement.compileNode() - Table not defined");

    const prefix = (this.pretty ? this._STR_CONCAT : " ");
    const into = typeof table === "string" ? this.escapeIdentifier(table)
                                           : table.compileNode(this);

    var out = "";
    var prevCols = null;

    for (var i = 0, len = objects.length; i < len; i++) {
      const object = objects[i];
      var cols = "";
      var vals = "";

      for (var k in object) {
        if (cols) cols += ", ";
        if (vals) vals += ", ";

        cols += this.escapeIdentifier(k);
        vals += this._compile(object[k], typeMapping[k]);
      }

      if (cols !== prevCols) {
        prevCols = cols;
        if (out) out += ";\n";

        if (cols)
          out += "INSERT INTO" + this.concat(into + " (" + cols + ")") + BLANK + "VALUES";
        else
          out += "INSERT INTO" + this.concat(into);
      }
      else {
        out += ",";
      }

      if (cols)
        out += prefix + "(" + vals + ")";
      else
        out += prefix + "DEFAULT VALUES";
    }

    // Compile `WITH ...`
    if (with_.length !== 0)
      out = this._compileWithClause(with_) + BLANK + out;

    // Compile `RETURNING ...` or `OUTPUT ...`.
    if (features.returning && returning.length !== 0)
      out += BLANK + this._compileReturning(returning, "INSERT");

    return out;
  }

  /**
   * Compiles UPDATE statement.
   *
   * @param {xql.node.UpdateStatement} node Update node.
   * @return {string} Compiled UPDATE.
   *
   * @private
   */
  _compileUpdate(node) {
    const BLANK = this._STR_BLANK;
    const COMMA = this._STR_COMMA;
    const features = this.features;

    const with_ = node._with;
    const table = node._table;
    const returning = node._fieldsOrReturning || NoArray;

    // Compile `UPDATE ...`
    if (!table)
      throwCompileError("UpdateStatement.compileNode() - Table not defined");

    var t = "";
    if (typeof table === "string")
      t = this.escapeIdentifier(table);
    else
      t = table.compileNode(this);
    var out = "UPDATE" + this.concat(t);

    // Compile `WITH ...`
    if (with_.length !== 0)
      out = this._compileWithClause(with_) + BLANK + out;

    // Compile `SET ...`
    const objects = node._values;

    if (!objects)
      throwCompileError("UpdateStatement.compileNode() - No data to update provided");

    if (objects.length !== 1)
      throwCompileError("UpdateStatement.compileNode() - Can only update one record (" + objects.length + " provided)");

    const values = objects[0];
    const typeMapping = node._typeMapping || NoObject;

    t = "";
    for (var k in values) {
      var value = values[k];
      var compiled = this._compile(value, typeMapping[k]);

      if (t) t += COMMA;
      t += this.escapeIdentifier(k) + " = " + compiled;
    }
    out += BLANK + "SET" + this.concat(t);

    // Compile `FROM table[, table[, ...]]` or `FROM table JOIN table [, JOIN ...]`.
    const from = node._fromOrUsing;
    if (from)
      out += BLANK + "FROM" + this.concat(this._compileFromOrUsing(from));

    // Compile `WHERE ...`.
    const where = node._where;
    if (where && where._values.length)
      out += BLANK + "WHERE" + this.concat(this._compileWhereOrHaving(where));

    // Compile `OFFSET ...` / `LIMIT ...`.
    const offset = node._offset;
    const limit = node._limit;

    if (offset || limit)
      out += BLANK + this._compileOffsetLimit(offset, limit);

    // Compile `RETURNING ...` or `OUTPUT ...`.
    if (features.returning && returning.length !== 0)
      out += BLANK + this._compileReturning(returning, "UPDATE");

    return out;
  }

  /**
   * Compiles DELETE statement.
   *
   * @param {xql.node.DeleteStatement} node Delete node.
   * @return {string} Compiled DELETE.
   *
   * @private
   */
  _compileDelete(node) {
    var out = "";
    var t = "";

    const BLANK = this._STR_BLANK;
    const features = this.features;

    const with_ = node._with;
    const table = node._table;
    const returning = node._fieldsOrReturning || NoArray;

    // Compile `DELETE FROM ...`
    if (!table)
      throwCompileError("DeleteStatement.compileNode() - Table not defined");

    if (typeof table === "string")
      t = this.escapeIdentifier(table);
    else
      t = table.compileNode(this);

    out += "DELETE FROM" + this.concat(t);

    // Compile `WITH ...`
    if (with_.length !== 0)
      out = this._compileWithClause(with_) + BLANK + out;

    // Compile `USING table[, table[, ...]]` or `USING table JOIN table [, JOIN ...]`.
    const using = node._fromOrUsing;
    if (using)
      out += BLANK + "USING" + this.concat(this._compileFromOrUsing(using));

    // Compile `WHERE ...`
    const where = node._where;
    if (where && where._values.length)
      out += BLANK + "WHERE" + this.concat(this._compileWhereOrHaving(where));

    // Compile `OFFSET ...` / `LIMIT ...`.
    const offset = node._offset;
    const limit = node._limit;

    if (offset || limit)
      out += BLANK + this._compileOffsetLimit(offset, limit);

    // Compile `RETURNING ...` or `OUTPUT ...`.
    if (features.returning && returning.length !== 0)
      out += BLANK + this._compileReturning(returning, "DELETE");

    return out;
  }

  /**
   * Compiles compound statement (UNION, INTERSECT, EXCEPT).
   *
   * @param {xql.node.CompoundStatement} node Compound node.
   * @return {string} Compiled compound query.
   *
   * @private
   */
  _compileCompound(node) {
    const BLANK = this._STR_BLANK;

    var combineOp = node._type;
    const flags = node._flags;
    if (flags & NF.All)
      combineOp += " ALL";

    const with_ = node._with;
    const queries = node._values;
    const separator = BLANK + combineOp + BLANK;

    var out = "";
    for (var i = 0, len = queries.length; i < len; i++) {
      var query = queries[i];
      var compiled = this._compile(query);

      if (out)
        out += separator;

      if (query.mustWrap(this, node))
        compiled = this._wrap(compiled);

      out += compiled;
    }

    // Compile `WITH ...`.
    if (with_.length !== 0)
      out = this._compileWithClause(with_) + BLANK + out;

    // Compile `ORDER BY ...`.
    const orderBy = node._orderBy;
    if (orderBy && orderBy.length)
      out += BLANK + "ORDER BY" + this.concat(this._compileOrderBy(orderBy));

    // Compile `OFFSET ...` / `LIMIT ...`.
    const offset = node._offset;
    const limit = node._limit;

    if (offset || limit)
      out += BLANK + this._compileOffsetLimit(offset, limit);

    return out;
  }

  _compileWithClause(nodeArray) {
    const COMMA = this._STR_COMMA;

    var out = "";
    for (var i = 0; i < nodeArray.length; i++)
      out = (out ? out + COMMA : "") + nodeArray[i].compileNode(this);
    return "WITH" + this.concat(out);
  }

  _compileJoin(node) {
    var out = "";

    var type = node._type;
    var keyword = "";

    switch (type) {
      case ""     : // ... Fall through ...
      case "CROSS": keyword = " CROSS JOIN "      ; break;
      case "INNER": keyword = " INNER JOIN "      ; break;
      case "LEFT" : keyword = " LEFT OUTER JOIN " ; break;
      case "RIGHT": keyword = " RIGHT OUTER JOIN "; break;
      case "FULL" : keyword = " FULL OUTER JOIN " ; break;

      // In case that the `JOIN` is backend specific.
      default:
        keyword = " " + type + " JOIN ";
        break;
    }

    var lo = node._left;
    var ro = node._right;

    var left = typeof lo === "string" ? this.escapeIdentifier(lo) : lo.compileNode(this);
    var right = typeof ro === "string" ? this.escapeIdentifier(ro) : ro.compileNode(this);

    out = left + keyword + right;

    // Compile `USING (...)` clause.
    var condition = node._condition;
    if (isArray(condition)) {
      var t = "";

      for (var i = 0, len = condition.length; i < len; i++) {
        var identifier = condition[i];

        if (t)
          t += ", ";

        if (typeof identifier === "string")
          t += this.escapeIdentifier(identifier);
        else
          t += identifier.compileNode(this);
      }

      if (t)
        out += " USING (" + t + ")";
    }
    // Compile `ON ...` clause.
    else if (condition instanceof Node) {
      out += " ON " + condition.compileNode(this);
    }

    var alias = node._alias;
    if (alias)
      out += " AS " + this.escapeIdentifier(alias);

    return out;
  }

  _compileSort(node) {
    var out;

    const value = node._value;
    const flags = node._flags;

    // Value of type:
    //   - `number` - describes column order,
    //   - `string` - describes column name.
    //   - `Node`   - SQL expression/column.
    if (typeof value === "number")
      out = this.escapeNumber(value);
    else if (typeof value === "string")
      out = this.escapeIdentifier(value);
    else if (value instanceof Node)
      out = value.compileNode(this);
    else
      throwCompileError("Sort.compileNode() - Invalid value type " + typeof value);

    const sortOrder = (flags & NF.Ascending ) ? " ASC"  :
                      (flags & NF.Descending) ? " DESC" : "";

    if ((flags & (NF.NullsFirst | NF.NullsLast)) === 0)
      return out + sortOrder;

    const features = this.features;
    const nullsFirst = flags & NF.NullsFirst ? true : false;

    if (features.nullsOrdering)
      return out + sortOrder + (nullsFirst ? " NULLS FIRST" : " NULLS LAST");

    // Unsupported `NULLS FIRST` and `NULLS LAST`. The best we can do is to omit
    // it completely if the DB sorts the records the requested way by default.
    const nullsFirstByDB = features.nullsSortBottom ? (flags & NF.Descending) !== 0
                                                    : (flags & NF.Descending) === 0;

    if (nullsFirst === nullsFirstByDB)
      return out + sortOrder;

    // Okay, we want the opposite of what DB does, one more expression
    // that precedes the current one is needed: `<column> IS [NOT] NULL`.
    if (nullsFirst)
      return "(" + out + " IS NOT NULL)" + this._STR_COMMA + out + sortOrder;
    else
      return "(" + out + " IS NULL)"     + this._STR_COMMA + out + sortOrder;
  }

  _compileGroupBy(groupBy) {
    const COMMA = this._STR_COMMA;

    var out = "";
    for (var i = 0, len = groupBy.length; i < len; i++) {
      var group = groupBy[i];
      if (out) out += COMMA;

      // Group can be in a form of `string` or `Node`.
      if (typeof group === "string")
        out += this.escapeIdentifier(group);
      else
        out += group.compileNode(this);
    }
    return out;
  }

  _compileOrderBy(orderBy) {
    const COMMA = this._STR_COMMA;

    var out = "";
    for (var i = 0, len = orderBy.length; i < len; i++) {
      var sort = orderBy[i];
      if (out) out += COMMA;
      out += sort.compileNode(this);
    }
    return out;
  }

  _compileFields(args) {
    const COMMA = this._STR_COMMA;

    var out = "";
    for (var i = 0, len = args.length; i < len; i++) {
      var column = args[i];
      if (out) out += COMMA;

      // Compile column identifier or expression.
      if (typeof column === "string") {
        out += this.escapeIdentifier(column);
      }
      else {
        var compiled = column.compileNode(this);
        if (column.mustWrap(this, null))
          out += this._wrap(compiled);
        else
          out += compiled;
      }
    }
    return out;
  }

  // No RETURNING/OUTPUT implementation.
  _compileReturning$NoImpl(args, type) {
    return "";
  }

  // Compiles RETURNING ... (PGSQL, the same syntax as VALUES).
  _compileReturning$Base(args, type) {
    return "RETURNING" + this.concat(this._compileFields(args));
  }

  // Compiles "OUTPUT ...".
  _compileReturning$Output(args, type) {
    const COMMA = this._STR_COMMA;
    const prefix = StatementToOutputKeywordMap[type] + ".";

    var out = "";
    for (var i = 0, len = args.length; i < len; i++) {
      var column = args[i];
      if (out) out += COMMA;

      // Compile column identifier or expression.
      if (typeof column === "string") {
        out += prefix + this.escapeIdentifier(column);
      }
      else if (column instanceof Identifier) {
        out += prefix + this._compile(column);
      }
      else {
        var compiled = column.compileNode(this);
        if (column.mustWrap(this, null))
          out += this._wrap(compiled);
        else
          out += compiled;
      }
    }

    return "OUTPUT" + this.concat(out);
  }

  _compileFromOrUsing(node) {
    if (typeof node === "string")
      return this.escapeIdentifier(node);
    else
      return node.compileNode(this);
  }

  _compileWhereOrHaving(condition) {
    var out = "";

    var list = condition._values;
    var i, len = list.length;

    if (len === 1)
      return list[0].compileNode(this);

    for (i = 0; i < len; i++) {
      var expression = list[i];
      var compiled = expression.compileNode(this);

      if (out)
        out += " " + condition._type + " ";

      if (expression.mustWrap(this, null))
        out += "(" + compiled + ")";
      else
        out += compiled;
    }

    return out;
  }

  _compileOffsetLimit$Simple(offset, limit) {
    const CONCAT = this._STR_CONCAT;
    var out = limit ? "LIMIT" + CONCAT + String(limit) : "";

    if (!offset)
      return out;

    if (out)
      out += this._STR_BLANK;
    return out + "OFFSET" + CONCAT + String(offset);
  }

  _compileOffsetLimit$TopN(offset, limit) {
    const CONCAT = this._STR_CONCAT;
    var out = offset || limit ? "OFFSET" + CONCAT + String(offset) + (offset === 1 ? " ROW" : " ROWS") : "";

    if (!limit)
      return out;

    if (out)
      out += this._STR_BLANK;
    return out + "FETCH NEXT" + CONCAT + String(limit) + (limit === 1 ? " ROW ONLY" : " ROWS ONLY");
  }
}
xql$dialect.Context = Context;

// ============================================================================
// [xql.dialect.pgsql]
// ============================================================================

(function() {

const reEscapeChars = /[\x00-\x1F\'\\]/g;
const reSubstituteChars = /[\"\$\'\?]/g;

function fnEscapeString(s) {
  const c = s.charCodeAt(0);
  switch (c) {
    case  0: return "\\x00"; // Only works for BYTEA.
    case  8: return "\\b";
    case  9: return "\\t";
    case 10: return "\\n";
    case 12: return "\\f";
    case 13: return "\\r";
    case 39: return "\\'";
    case 92: return "\\\\";
    default: return "\\x" + (c >> 4).toString(16) + (c & 15).toString(16);
  }
}

/**
 * PostgreSQL context.
 *
 * @private
 */
class PGSQLContext extends Context {
  constructor(options) {
    super("pgsql", options);

    // Setup Postgres features.
    Object.assign(this.features, {
      quoteStyle       : QuoteStyle.Double,
      nativeBoolean    : true,
      nativeRange      : true,
      nativeArray      : true,
      nativeJSON       : true,
      nativeJSONB      : true,
      nativeHSTORE     : true,
      nullsOrdering    : true,
      nullsSortBottom  : true,
      defaultValues    : true,
      leastGreatest    : "LEAST|GREATEST",
      returning        : "RETURNING",
      specialNumbers   : true
    });

    // Update everything the base Context understands.
    this._updateInternalData();

    // Override everything, which is Postgres specific.
    this._DB_POS_INF = "'Infinity'";
    this._DB_NEG_INF = "'-Infinity'";
    this._DB_NAN     = "'NaN'";
  }

  /** @override */
  escapeString(value) {
    var oldLength = value.length;
    value = value.replace(reEscapeChars, fnEscapeString);

    if (value.length !== oldLength) {
      // We have to tell Postgres explicitly that the string is escaped by a
      // C-style escaping sequence(s).
      return "E'" + value + "'";
    }
    else {
      // String doesn't contain any character that has to be escaped. We can
      // use simply '...'.
      return "'" + value + "'";
    }
  }

  /** @override */
  escapeBuffer(value) {
    return "E'\\x" + blobToHex(value) + "'";
  }

  /** @override */
  escapeArray(value, nested) {
    var out = "";
    var i = 0, len = value.length;

    if (len === 0)
      return "'{}'";

    do {
      var element = value[i];
      if (out) out += ", ";

      if (isArray(element))
        out += this.escapeArray(element, true);
      else
        out += this._compile(element);
    } while (++i < len);

    if (nested)
      return "[" + out + "]";
    else
      return "ARRAY[" + out + "]";
  }

  escapeJSON(value, type) {
    var out = this.escapeString(JSON.stringify(value));
    return type ? out + "::" + type : out;
  }

  /** @override */
  substitute(query, bindings) {
    var input = "";
    var output = "";

    if (typeof query === "string")
      input = query;
    else if (query instanceof Node)
      input = query.compileNode(this);
    else
      input = query.toString();

    var i = input.search(reSubstituteChars);
    if (i === -1)
      return input;

    var len = input.length;
    var iStart = 0;

    // Substitution mode:
    //   0  - Not set.
    //   36 - `$`.
    //   63 - `?`.
    var mode = 0;

    // Bindings index, incremented if query contains `?` or parsed if `$`.
    var bIndex = 0;
    // Count of bindings available.
    var bLength = bindings.length;

    while (i < len) {
      var c = input.charCodeAt(i);
      i++;

      // Check if the character is one of the following:
      //   " - 34
      //   $ - 36
      //   ' - 39
      if (c <= 39) {
        // Parse `"` - `"..."` section. Skip until the closing `"`.
        //
        // The only possible escaping sequence here is `""`.
        if (c === 34) {
          for (;;) {
            // Stop at the end of the string.
            if (i === len)
              break;

            c = input.charCodeAt(i);
            i++;

            // Skip anything that is not `"`.
            //
            // `"` === 34
            if (c !== 34)
              continue;

            // Stop at the end of the string.
            if (i === len)
              break;

            // Only continue if this is an escape sequence `""`.
            //
            // `"` === 34
            c = input.charCodeAt(i);
            if (c !== 34)
              break;

            i++;
          }
        }

        // Parse `'` - `'...'` section; skip until the closing `'`.
        //
        // There are several possibilities of escaping.
        //
        //   a) If the string starts with `E` prefix, it is using C-like escaping
        //      sequence `\?` where `\` is an escape prefix and `?` is the
        //      character.
        //
        //   b) If the string doesn't start with `E` prefix it is using SQL
        //      escaping, which escapes `''` to `'`.
        else if (c === 39) {
          // 'E' === 69.
          // 'e' === 101.
          //
          // We have to check `i - 2`, because `i` has been incremented already.
          // The expression `(x & ~32)` makes ASCII character `x` lowercased.
          if (i >= 2 && (input.charCodeAt(i - 2) & ~32) === 69) {
            // TODO: Add support for binary in form `E'\x`

            // a) String is escaped by using C-like (vendor-specific) escaping.
            for (;;) {
              // Stop at the end of the string.
              if (i >= len)
                break;

              c = input.charCodeAt(i);
              i++;

              // Break if matching `'` has been found.
              //
              // `'` === 39
              if (c === 39)
                break;

              // Continue if the character is not an escaping sequence `\\`.
              //
              // `\\` === 92.
              if (c !== 92)
                continue;

              // Next character is ignored.
              i++;
            }
          }
          else {
            // b) String is escaped by using plain SQL escaping.
            for (;;) {
              // Stop at the end of the string.
              if (i === len)
                break;

              c = input.charCodeAt(i);
              i++;

              // Skip anything that is not `'`.
              //
              // `'` === 39
              if (c !== 39)
                continue;

              // Stop at the end of the string.
              if (i === len)
                break;

              // Only continue if this is an escape sequence `''`.
              //
              // `'` === 39
              c = input.charCodeAt(i);
              if (c !== 39)
                break;

              i++;
            }
          }
        }

        // Parse `$`.
        else if (c === 36) {
          if (mode !== c) {
            if (mode !== 0) {
              throwCompileError("Substitute() - Mixed substitution marks, " +
                "initial '" + String.fromCharCode(mode) + "'" +
                "is followed by '" + String.fromCharCode(c) + "'");
            }
            mode = c;
          }

          // Flush accumulated input.
          output += input.substring(iStart, i - 1);

          bIndex = 0;
          iStart = i;

          // Parse the number `[0-9]+` directly to `bIndex`.
          while (i < len) {
            c = input.charCodeAt(i);
            // `0` === 48
            // `9` === 57
            if (c < 48 || c > 57)
              break;

            bIndex = bIndex * 10 + (c - 48);
            if (bIndex > bLength)
              throwCompileError("Substitute() - Index '" + bIndex + "' of range (" + bLength + ")");
            i++;
          }

          if (bIndex === 0)
            throwCompileError("Substitute() - Index can't be zero");
          bIndex--;

          if (iStart === i)
            throwCompileError("Substitute() - Missing number after '$' mark");

          // Substitute.
          output += this._compile(bindings[bIndex]);
          iStart = i;
        }
      }
      // Check if the character is a question mark (63).
      else if (c === 63) {
        // Basically a duplicate from `$`.
        if (mode !== c) {
          if (mode !== 0) {
            throwCompileError("Substitute() - Mixed substitution marks, " +
              "initial '" + String.fromCharCode(mode) + "'" +
              "is followed by '" + String.fromCharCode(c) + "'");
          }
          mode = c;
        }

        if (bIndex >= bLength)
          throwCompileError("Substitute() - Index '" + bIndex + "' out of range (" + bLength + ")");

        // Flush accumulated input.
        output += input.substring(iStart, i - 1);

        // Substitute.
        output += this._compile(bindings[bIndex]);

        // Advance.
        iStart = i;
        bIndex++;
      }
    }

    // Don't call substring() if nothing have changed.
    if (iStart === 0)
      return input;

    // Flush the remaining input (if any).
    if (iStart !== len)
      output += input.substring(iStart);

    return output;
  }
}
xql$dialect.add("pgsql", PGSQLContext);

})();

// ============================================================================
// [xql.dialect.mysql]
// ============================================================================

(function() {

const reEscapeChars = /[\x00\b\t\n\r\x1A\'\\]/g;

function fnEscapeString(s) {
  const c = s.charCodeAt(0);
  switch (c) {
    case  0: return "\\0";
    case  8: return "\\b";
    case  9: return "\\t";
    case 10: return "\\n";
    case 13: return "\\r";
    case 26: return "\\Z";
    case 39: return "''";
    case 92: return "\\\\";
  }
}

/**
 * MySQL/MariaDB context.
 *
 * @private
 */
class MySQLContext extends Context {
  constructor(options) {
    super("mysql", options);

    Object.assign(this.features, {
      quoteStyle       : QuoteStyle.Grave,
      nativeBoolean    : true,
      defaultValues    : true,
      leastGreatest    : "LEAST|GREATEST"
    });

    this._updateInternalData();
  }

  /** @override */
  escapeString(value) {
    return "'" + value.replace(reEscapeChars, fnEscapeString) + "'";
  }

  /** @override */
  _compileOffsetLimit$Simple(offset, limit) {
    // Compile either `LIMIT <limit>` or `LIMIT <offset>, <limit>`.
    const limitStr = limit ? String(limit) : "18446744073709551615";
    if (offset === 0)
      return "LIMIT" + this._STR_CONCAT + limitStr;
    else
      return "LIMIT" + this._STR_CONCAT + String(offset) + ", " + limitStr;
  }
}
xql$dialect.add("mysql", MySQLContext);

})();

// ============================================================================
// [xql.dialect.mssql]
// ============================================================================

(function() {

const reOkayString = /^[\x01-\x26\x28-\x7F]*$/;
const reEscapeChars = /[\x00\']/g;

function fnEscapeString(s) {
  const c = s.charCodeAt(0);
  switch (c) {
    case 0: return "'+CODE(0)+N'";
    case 39: return "''";
  }
}

/**
 * MSSQL context.
 *
 * @private
 */
class MSSQLContext extends Context {
  constructor(options) {
    super("mssql", options);

    Object.assign(this.features, {
      quoteStyle       : QuoteStyle.Brackets,
      nativeBoolean    : false,
      defaultValues    : true,
      selectTopN       : true,
      leastGreatest    : "IIF",
      returning        : "OUTPUT"
    });

    this._updateInternalData();
  }

  /** @override */
  escapeString(value) {
    // It seems best to just pre-scan the string and then decide what to do.
    if (reOkayString.test(value))
      return "'" + value + "'";
    else
      return "N'" + value.replace(reEscapeChars, fnEscapeString) + "'";
  }
}
xql$dialect.add("mssql", MSSQLContext);

})();

// ============================================================================
// [xql.dialect.sqlite]
// ============================================================================

(function() {

/**
 * SQLite context.
 *
 * @private
 */
class SQLiteContext extends Context {
  constructor(options) {
    super("sqlite", options);

    Object.assign(this.features, {
      quoteStyle       : QuoteStyle.Double,
      leastGreatest    : "MIN|MAX"
    });

    this._updateInternalData();
  }

  /** @override */
  escapeString(value) {
    var out = "";

    var i = 0;
    var m = 0;
    var len = value.length;

    if (!len)
      return "''";

    var c = value.charCodeAt(0);
    while (i < len) {
      if (c < 32) {
        // Blob part.
        if (i === 0)
          out += "''"; // Edge case, always form TEXT, not BLOB.
        out += "||x'";

        do {
          out += (c >> 4).toString(16) + (c & 15).toString(16);
          if (++i >= len)
            break;
          c = value.charCodeAt(i);
        } while (c < 32);
        out += "'";
      }
      else {
        // Text part.
        out += out ? "||'" : "'";
        if (c === 39)
          out += "'";
        m = i;

        for (;;) {
          if (++i >= len)
            break;

          c = value.charCodeAt(i);
          if (c > 39) continue;
          if (c < 32) break;

          if (c === 39) {
            out += value.substring(m, i + 1);
            m = i;
          }
        }

        out += value.substring(m, i) + "'";
      }
    }

    return out;
  }
}
xql$dialect.add("sqlite", SQLiteContext);

})();

// ============================================================================
// [xql.node]
// ============================================================================

/**
 * SQL nodes namespace.
 *
 * @namespace
 * @alias xql.node
 */
const xql$node = xql.node = {};

/**
 * SQL node - basic building block that implements the SQL's expression tree.
 *
 * `Node` doesn't have any functionality and basically only initializes `_type`,
 * `_flags` and `_alias` members. Classes that inherit `Node` can omit calling
 * `Node`'s constructor for performance reasons, but if you do so, please
 * always initialize members in a `[_type, _flags, _alias]` order.
 *
 * @param {string} type Type of the node.
 * @param {string} |alias| Node alias as specified by SQL's `AS` keyword.
 *
 * @alias xql.node.Node
 */
class Node {
  constructor(type, alias) {
    this._type = type || "";
    this._flags = 0;
    this._alias = alias || "";

    const opInfo = OpInfo.get(type);
    if (opInfo) {
      this._type = opInfo.name;
      this._flags |= opInfo.nodeFlags;
    }
  }

  /**
   * Gets whether the returned expression must be wrapped in parentheses if not alone.
   *
   * @param {Context} ctx Context.
   * @param {Node} parent Parent node or null if there is no parent.
   * @return {boolean} Whether the expression must be wrapped.
   */
  mustWrap(ctx, parent) {
    return parent != null;
  }

  /**
   * Returns true if the node can be negated (by either replacing its operator
   * or by adding a `NodeFlags.Not` to its flags. Please note that if a `negate()`
   * is called on node, which cannot be negated an exteption would be thrown.
   */
  canNegate() {
    const info = OpInfo.get(this._type);
    return info && (info.not != null || OpFlags.nameNot != null);
  }

  /**
   * Returns whether the node represents a statement that can be executed. Must
   * return true for all nodes that inherit `xql.node.Statement`.
   *
   * @return {boolean} True if the compiled query can be executed, false otherwise.
   */
  isStatement() {
    return (this._flags & NF.Statement) != 0;
  }

  /**
   * Compiles the node into a valid SQL string.
   *
   * @note This function is reimplemented by each `Node` and provides a foundation
   * to compile building blocks of the query independently. The string returned
   * doesn't have to be functional alone, however, it will function if combined
   * with the rest of the expression tree.
   *
   * @param {Context} ctx Context.
   * @return {string} SQL string.
   */
  compileNode(ctx) {
    throwTypeError("Abstract method called");
  }

  compileQuery(ctx) {
    deprecated("xql.Node.compileQuery() is deprecated, use xql.Node.compileStatement() instead");
    return this.compileStatement(ctx);
  }

  /**
   * Compiles the node and adds a semicolon ';' at the end of the compiled string.
   *
   * @param {Context} ctx Context.
   * @return {string} SQL query.
   */
  compileStatement(ctx) {
    return this.compileNode(ctx) + ";";
  }

  /**
   * Gets the type of the node.
   *
   * @return {string} Type of the node.
   */
  getType() {
    return this._type;
  }

  /**
   * Sets the type of the node.
   *
   * @note The type of the node should be always set when the Node is created.
   * This setter is provided for some edge use-cases, use at your own risk.
   *
   * @param {string} type Type of the node.
   * @return {this}.
   */
  setType(type) {
    this._type = type;
    return this;
  }

  /**
   * Gets whether the node contains the given `flag`.
   *
   * @return {boolean} Whether the flag is enabled or disabled.
   */
  getFlag(flag) {
    return (this._flags & flag) !== 0;
  }

  /**
   * Sets a node `flag`.
   *
   * @param {number} flag Flag to set.
   * @return {this}
   */
  setFlag(flag) {
    this._flags |= flag;
    return this;
  }

  /**
   * Clears a node `flag`.
   *
   * @param {number} flag Flag to clear.
   * @return {this}
   */
  clearFlag(flag) {
    this._flags &= ~flag;
    return this;
  }

  /**
   * Toggles a node `flag`.
   *
   * @param {number} flag Flag to clear.
   * @return {this}
   */
  toggleFlag(flag) {
    this._flags ^= flag;
    return this;
  }

  /**
   * Replaces the `flagToClear` flag with `flagToSet` flag.
   *
   * @param {number} flagToClear Flag to clear.
   * @param {number} flagToSet Flag to set.
   * @return {this}
   */
  replaceFlag(flagToClear, flagToSet) {
    this._flags = (this._flags & ~flagToClear) | flagToSet;
    return this;
  }

  /**
   * Gets the alias of the node or expression, which compiles as `AS ...`.
   *
   * @return {string} SQL alias.
   */
  getAlias() {
    return this._alias;
  }

  /**
   * Sets the alias of the node or expression, which compiles as `AS ...`.
   *
   * @note Not all SQL nodes support aliases. It's mostly for SELECT columns.
   *
   * @param {string} |alias| SQL alias.
   * @return {this}
   */
  setAlias(alias) {
    this._alias = alias;
    return this;
  }

  /*
   * Negates this node (most likely an operator).
   */
  negate() {
    const info = OpInfo.get(this._type);
    if (info) {
      if (info.not) {
        this._type = info.not.name;
        return this;
      }

      if (info.nameNot != null) {
        this._flags ^= NF.Not;
        return this;
      }
    }

    throwTypeError("This node doesn't support negation");
  }

  /**
   * The same as calling `setAlias(alias)`.
   *
   * @param {string} |alias| SQL alias.
   * @return {this}
   */
  AS(alias) {
    this._alias = alias;
    return this;
  }

  EQ(b) { return BINARY_OP(this, "=", b); }
  NE(b) { return BINARY_OP(this, "<>", b); }
  LT(b) { return BINARY_OP(this, "<", b); }
  LE(b) { return BINARY_OP(this, "<=", b); }
  GT(b) { return BINARY_OP(this, ">", b); }
  GE(b) { return BINARY_OP(this, ">=", b); }

  // Returns a new Node which contains `this BETWEEN a AND b` expression
  BETWEEN(a, b) { return xql.BETWEEN(this, a, b); }

  // Returns a new Node which contains `this NOT BETWEEN a AND b` expression
  NOT_BETWEEN(a, b) { return xql.NOT_BETWEEN(this, a, b); }

  // Returns a new Node which contains `this IN b` expression.
  IN(b) { return BINARY_OP(this, "IN", b); }

  // Returns a new Node which contains `this NOT IN b` expression.
  NOT_IN(b) { return BINARY_OP(this, "NOT IN", b); }
}
xql$node.Node = Node;

// ============================================================================
// [xql.Raw]
// ============================================================================

/**
 * SQL RAW expression.
 *
 * @param {string} expression Expression string.
 * @param {array} [bindings] Bindings array used by the expression.
 *
 * @alias xql.node.Raw
 */
class Raw extends Node {
  constructor(expression, bindings) {
    super("RAW", "");
    this._value = expression || "";
    this._bindings = bindings || null;
  }

  /** @override */
  mustWrap(ctx, parent) {
    return false;
  }

  /** @override */
  compileNode(ctx) {
    var out = this._value;

    var bindings = this._bindings;
    if (bindings)
      out = ctx.substitute(out, bindings);

    var alias = this._alias;
    if (alias)
      out += " AS " + ctx.escapeIdentifier(alias);

    return out;
  }

  /**
   * Gets the raw expression.
   *
   * @return {string}.
   */
  getExpression() {
    return this._value;
  }

  /**
   * Sets the raw expression to `expression`.
   *
   * @param {string} expression Raw expression.
   * @return {this}.
   */
  setExpression(expression) {
    this._value = expression;
    return this;
  }

  /**
   * Gets the raw expression's bindings or `null` if no bindings are provided.
   *
   * @return {?array}
   */
  getBindings() {
    return this._bindings;
  }

  /**
   * Sets the raw expression's bindings.
   *
   * @param {?array} bindings The raw expression's bindings, `null` to disable.
   * @return {this}
   */
  setBindings(bindings) {
    this._bindings = bindings || null;
    return this;
  }
}
xql$node.Raw = Raw;

/**
 * Constructs a RAW query node.
 *
 * @param {string} raw Raw query string (won't be escaped).
 * @param {array} [bindings] Data that will be sustituted in `raw`.
 * @return {Raw}
 *
 * @alias xql.RAW
 */
function RAW(raw, bindings) {
  return new Raw(raw, bindings);
}
xql.RAW = RAW;

// ============================================================================
// [xql.Unary]
// ============================================================================

/**
 * SQL unary node.
 *
 * @alias xql.node.Unary
 */
class Unary extends Node {
  constructor(type, value) {
    super(type, "");
    this._value = value;
  }

  /** @override */
  mustWrap(ctx, parent) {
    return false;
  }

  /** @override */
  compileNode(ctx) {
    return ctx._compileUnaryNode(this);
  }

  /**
   * Gets the unary (child) value.
   *
   * @return {*}
   */
  getValue() {
    return this._value;
  }

  /**
   * Sets the unary (child) value to `value`.
   *
   * @param {*} value A new (child) value.
   * @return {this}
   */
  setValue(value) {
    this._value = value;
    return this;
  }

  static makeWrap(type, flags, ctor) {
    if (!ctor)
      ctor = Unary;

    return function(value) {
      return {
        __proto__: ctor.prototype,
        _type    : type,
        _flags   : flags,
        _alias   : "",
        _value   : value
      };
    }
  }
}
xql$node.Unary = Unary;

function UNARY_OP(op, value) {
  return {
    __proto__: Unary.prototype,
    _type    : op,
    _flags   : 0,
    _alias   : "",
    _value   : value
  };
}

// ============================================================================
// [xql.Binary]
// ============================================================================

/**
 * SQL binary node.
 *
 * @alias xql.node.Binary
 */
class Binary extends Node {
  constructor(left, type, right, alias) {
    super(type, alias);
    this._left = left;
    this._right = right;
  }

  /** @override */
  mustWrap(ctx, parent) {
    if (!parent)
      return false;

    const type = this._type;
    if (parent._type === type) {
      if (type === "+")
        return false;
    }

    return true;
  }

  /** @override */
  compileNode(ctx) {
    return ctx._compileBinaryNode(this);
  }

  /**
   * Gets the left node or value.
   *
   * @return {*}
   */
  getLeft() {
    return this._left;
  }

  /**
   * Sets the left node or value.
   *
   * @param {*} value Left node or value.
   * @return {this}
   */
  setLeft(value) {
    this._left = value;
    return this;
  }

  /**
   * Adds a `value` to the left node, which must be array or compatible.
   *
   * @param {*} value Value to add.
   * @return {this}
   */
  addLeft(value) {
    var left = this._left;
    if (!left || typeof left.push !== "function")
      throwCompileError("Binary.addLeft() - Left operand is not array or compatible");

    left.push(value);
    return this;
  }

  /**
   * Gets the right node or value.
   *
   * @return {*}
   */
  getRight() {
    return this._right;
  }

  /**
   * Sets the right node or value.
   *
   * @param {*} value Right node or value.
   * @return {this}
   */
  setRight(right) {
    this._right = right;
    return this;
  }

  /**
   * Adds a `value` to the right node, which must be array or compatible.
   *
   * @param {*} value Value to add.
   * @return {this}
   */
  addRight(value) {
    var right = this._right;
    if (!right || typeof right.push !== "function")
      throwCompileError("Binary.addRight() - Right operand is not array or compatible");

    right.push(value);
    return this;
  }

  static makeWrap(type, flags, ctor) {
    if (!ctor)
      ctor = Binary;

    return function(left, right) {
      return {
        __proto__: ctor.prototype,
        _type    : type,
        _flags   : flags,
        _alias   : "",
        _left    : left,
        _right   : right
      };
    }
  }
}
xql$node.Binary = Binary;

function BINARY_OP(left, op, right) {
  const info = OpInfo.get(op);
  const flags = info ? info.nodeFlags : 0;

  return {
    __proto__: Binary.prototype,
    _type    : op,
    _flags   : flags,
    _alias   : "",
    _left    : left,
    _right   : right
  };
}

// ============================================================================
// [xql.NodeArray]
// ============================================================================

/**
 * A node that can have children (base for `Logical` and `Func`).
 *
 * @alias xql.node.NodeArray
 */
class NodeArray extends Node {
  constructor(type, values) {
    super(type, "");
    this._values = values || [];
  }

  /**
   * Append nodes or other data to the node.
   *
   * @note Behaves same as `Array.push()`.
   *
   * @param {...*} args Variable arguments.
   * @return {this}
   */
  push() {
    var values = this._values;
    for (var i = 0, len = arguments.length; i < len; i++)
      values.push(arguments[i]);
    return this;
  }

  concat(array) {
    var values = this._values;
    for (var i = 0, len = array.length; i < len; i++)
      values.push(array[i]);
    return this;
  }

  static makeWrap(type, flags, ctor) {
    if (!ctor)
      ctor = NodeArray;

    return function(...args) {
      return {
        __proto__: ctor.prototype,
        _type    : type,
        _flags   : flags,
        _alias   : "",
        _values  : args
      };
    }
  }
}
xql$node.NodeArray = NodeArray;

// ============================================================================
// [xql.Logical]
// ============================================================================

/**
 * SQL logical expression.
 *
 * @alias xql.node.Logical
 */
class Logical extends NodeArray {
  mustWrap(ctx, parent) {
    return parent != null && this._values.length > 1;
  }

  /** @override */
  compileNode(ctx) {
    var type = this._type;
    var out = "";

    var values = this._values;
    var separator = " " + type + " ";

    for (var i = 0, len = values.length; i < len; i++) {
      var value = values[i];
      var compiled = ctx._compile(value);

      if (out)
        out += separator;

      if (value instanceof Node && value.mustWrap(ctx, this))
        out += `(${compiled})`;
      else
        out += compiled;
    }

    return out;
  }
}
xql$node.Logical = Logical;

// ============================================================================
// [xql.ConditionMap]
// ============================================================================

/**
 * Node that holds conditional expressions stored in a JS object, where each
 * key represents table column and each value is the condition's expression.
 *
 * This node has been introduced as a low-overhead node that just holds the
 * passed object. All expressions are implicitly joined by logical `AND` or
 * `OR` operator.
 *
 * @alias xql.node.ConditionMap
 */
class ConditionMap extends Unary {
  /** @override */
  compileNode(ctx) {
    var out = "";

    var separator = ` ${this._type} `;
    var columns = this._value;

    for (var k in columns) {
      var value = columns[k];
      var compiled = ctx._compile(value);

      if (out)
        out += separator;

      out += ctx.escapeIdentifier(k);
      out += (compiled === "NULL") ? " IS " : " = ";

      if (value instanceof Node && value.mustWrap(ctx, this))
        out += `(${compiled})`;
      else
        out += compiled;
    }

    return out;
  }
}
xql$node.ConditionMap = ConditionMap;

// ============================================================================
// [xql.Identifier]
// ============================================================================

/**
 * SQL identifier.
 *
 * @alias xql.node.Identifier
 */
class Identifier extends Node {
  constructor(value, alias) {
    super("IDENTIFIER", alias);
    this._value = value;
  }

  /** @override */
  mustWrap(ctx, parent) {
    return false;
  }

  /** @override */
  compileNode(ctx) {
    var out = ctx.escapeIdentifier(this._value);
    var alias = this._alias;
    if (alias)
      out += " AS " + ctx.escapeIdentifier(alias);
    return out;
  }

  /**
   * Gets the name of the identifier.
   *
   * @note The identifier itself is stored in the node as `_value`, which makes
   * the interface similar to all other nodes.
   *
   * @return {string} Identifier's name.
   */
  getValue() {
    return this._value;
  }

  /**
   * Sets the name of the identifier.
   *
   * @param {string} value The new name of the identifier.
   * @return {this}
   */
  setValue(value) {
    this._value = value;
    return this;
  }
}
xql$node.Identifier = Identifier;

/**
 * Constructs SQL identifier.
 *
 * @param {string} value SQL identifier.
 * @param {string} [alias] SQL alias.
 * @return {Identifier}
 *
 * @alias xql.IDENT
 */
function IDENT(value, alias) {
  return {
    __proto__: Identifier.prototype,
    _type    : "",
    _flags   : 0,
    _alias   : alias || "",
    _value   : String(value)
  };
}
xql.IDENT  = IDENT;
xql.TABLE  = IDENT;
xql.COL    = IDENT;
xql.COLUMN = IDENT;

// ============================================================================
// [xql.Value]
// ============================================================================

/**
 * SQL value.
 *
 * Used in cases where it's difficult to automatically determine how the value
 * should be escaped (which can result in invalid query if determined wrong).
 *
 * `Value` node shouldn't be in general used for all types, only types where
 * the mapping is ambiguous and can't be automatically deduced. For example
 * PostgreSQL uses different syntax for `JSON` and `ARRAY`. In such case `xql`
 * has no knowledge which format to use and will choose ARRAY over JSON.
 *
 * Value is an alternative to schema. If schema is provided it's unnecessary
 * to wrap values to `Value` nodes.
 *
 * @param {string}  type  Type of the value.
 * @param {*}       value Data of the value.
 * @param {string}  [as]  SQL's AS clause, if given.
 *
 * @alias xql.node.Value
 */
class Value extends Node {
  constructor(value, type, alias) {
    super(type, alias);
    this._value = value;
  }

  /** @override */
  mustWrap(ctx, parent) {
    return false;
  }

  /** @override */
  compileNode(ctx) {
    var out = ctx.escapeValue(this._value, this._type);
    var alias = this._alias;
    if (alias)
      out += " AS " + ctx.escapeIdentifier(alias);
    return out;
  }

  /**
   * Gets the associated value.
   *
   * @return {*}
   */
  getValue() {
    return this._value;
  }

  /**
   * Sets the associated value.
   *
   * @param {*} value A new value to associate with.
   * @return {this}
   */
  setValue(value) {
    this._value = value;
    return this;
  }

  static makeWrap(fallbackType) {
    return function(value, type) {
      return {
        __proto__: Value.prototype,
        _type    : type || fallbackType,
        _flags   : 0,
        _alias   : "",
        _value   : value
      };
    };
  }

}
xql$node.Value = Value;

// ============================================================================
// [xql.Func]
// ============================================================================

/**
 * SQL function or aggregate expression.
 *
 * @alias xql.node.Func
 */
class Func extends NodeArray {
  constructor(type, args) {
    super(type, "");

    this._flags |= NF.All;
    this._values = args || [];
  }

  /** @override */
  mustWrap(ctx, parent) {
    return false;
  }

  /** @override */
  compileNode(ctx) {
    return ctx._compileFuncNode(this);
  }

  getArguments() {
    return this._values;
  }

  setArguments(args) {
    this._values = args || [];
    return this;
  }

  /**
   * Sets the `ALL` option of the aggregate (and clears the `DISTINCT` option).
   *
   * @return {this}
   */
  ALL() {
    return this.replaceFlag(NF.Distinct, NF.All);
  }

  /**
   * Sets the `DISTINCT` option of the aggregate (and clears the `ALL` option).
   *
   * @return {this}
   */
  DISTINCT() {
    return this.replaceFlag(NF.All, NF.Distinct);
  }

  static makeWrap(type, flags, ctor) {
    return NodeArray.makeWrap(type, flags, ctor || Func);
  }
}
xql$node.Func = Func;

function FUNC(name, ...args) { return new Func(name, args); };
xql.FUNC = FUNC;

// ============================================================================
// [xql.When]
// ============================================================================

/**
 * SQL when.
 *
 * @alias xql.node.When
 */
class When extends Binary {
  constructor(a, b) {
    super(a, "WHEN", b);
  }

  /** @override */
  mustWrap(ctx, parent) {
    return false;
  }

  /** @override */
  compileNode(ctx) {
    return "WHEN " + ctx._compile(this._left) + " THEN " + ctx._compile(this._right);
  }
}
xql$node.When = When;

function WHEN(a, b) {
  return new When(a, b);
};

xql.WHEN = WHEN;

// ============================================================================
// [xql.Case]
// ============================================================================

/**
 * SQL case.
 *
 * @alias xql.node.Case
 */
class Case extends NodeArray {
  constructor(input) {
    super("CASE");
    this._input = input;
    this._else = undefined;
  }

  /** @override */
  mustWrap(ctx, parent) {
    return false;
  }

  /** @override */
  compileNode(ctx) {
    var out = "CASE";
    var alias = this._alias;

    var input = this._input;
    var cases = this._values;
    var _else = this._else;

    if (input !== undefined)
      out += " " + ctx._compile(input);

    for (var i = 0; i < cases.length; i++)
      out += " " + cases[i].compileNode(ctx);

    if (_else !== undefined)
      out += " ELSE " + ctx._compile(_else);

    out += " END";
    if (alias)
      out = out + " AS " + ctx.escapeIdentifier(alias);
    return out;
  }

  getInput() {
    return this._input;
  }

  setInput(exp) {
    this._input = exp;
    return this;
  }

  getElse() {
    return this._else;
  }

  setElse(exp) {
    this._else = exp;
    return this;
  }

  WHEN(a, b) {
    this._values.push(WHEN(a, b));
    return this;
  }

  ELSE(exp) {
    this._else = exp;
    return this;
  }
}
xql$node.Case = Case;

function CASE(input) {
  return new Case(input);
}

xql.CASE = CASE;

// ============================================================================
// [xql.Sort]
// ============================================================================

/**
 * SQL sort expression.
 *
 * @alias xql.node.Sort
 */
class Sort extends Identifier {
  constructor(column, order, nulls) {
    var flags = 0;

    if (order && hasOwn.call(SortDirection, order))
      flags |= SortDirection[order];

    if (nulls && hasOwn.call(SortNulls, nulls))
      flags |= SortNulls[nulls];

    super("SORT", "");
    this._flags = flags;
    this._value = column;
  }

  /** @override */
  compileNode(ctx) {
    return ctx._compileSort(this);
  }

  /**
   * Gets the sorting order.
   *
   * @return {string} Empty string (if not set), "ASC", or "DESC".
   */
  getSortOrder() {
    var flags = this._flags;
    if (flags & NF.Descending)
      return "DESC";
    else if (flags & NF.Ascending)
      return "ASC";
    else
      return "";
  }

  /**
   * Sets the sorting order.
   *
   * @param {string} order Sorting order, must be "", "ASC", or "DESC".
   * @return {this}
   * @throws {CompileError} If `order` contains an invalid value.
   */
  setSortOrder(order) {
    var flags = this._flags & ~(NF.Ascending | NF.Descending);
    if (hasOwn.call(SortDirection, order))
      this._flags = flags | SortDirection[order];
    else
      throwCompileError("Sort.setSortOrder() - Invalid argument '" + order + "'");
    return this;
  }

  /**
   * Gets the sorting nulls option.
   *
   * @return {string} Either an empty string (if not set) or "NULLS FIRST" or
   *   "NULLS LAST".
   */
  getNullsOrder() {
    var flags = this._flags;
    if (flags & NF.NullsFirst)
      return "NULLS FIRST";
    else if (flags & NF.NullsLast)
      return "NULLS LAST";
    else
      return "";
  }

  /**
   * Sets the sorting nulls option.
   *
   * @param {string} order Sorting nulls option, must be "", "NULLS FIRST", or
   *   "NULLS LAST".
   * @return {this}
   * @throws {CompileError} If `order` contains an invalid value.
   */
  setNullsOrder(order) {
    var flags = this._flags & ~(NF.NullsFirst | NF.NullsLast);
    if (hasOwn.call(SortNulls, order))
      this._flags = flags | SortNulls[order];
    else
      throwCompileError("Sort.setSortOrder() - Invalid argument '" + order + "'");
    return this;
  }

  /**
   * Returns whether the sorting order is set to "ASC".
   *
   * @return {boolean} Whether the sorting order is "ASC". Returns false if the
   *   order has not been set (xql distinguish between not set, ASC, and DESC).
   */
  isAscending() {
    return (this._flags & NF.Ascending) !== 0;
  }

  /**
   * Returns whether the sorting order is set to "DESC".
   *
   * @return {boolean} Whether the sorting order is "DESC". Returns false if the
   *   order has not been set (xql distinguish between not set, ASC, and DESC).
   */
  isDescending() {
    return (this._flags & NF.Descending) !== 0;
  }

  /**
   * Returns whether the sorting nulls option is set to "NULLS FIRST".
   *
   * @return {boolean} Whether the sorting nulls is "NULLS FIRST". Returns
   *   false if the sorting nulls option is not "NULLS FIRST" or is not set.
   */
  hasNullsFirst() {
    return (this._flags & NF.NullsFirst) !== 0;
  }

  /**
   * Returns whether the sorting nulls option is set to "NULLS LAST".
   *
   * @return {boolean} Whether the sorting nulls is "NULLS LAST". Returns
   *   false if the sorting nulls option is not "NULLS LAST" or is not set.
   */
  hasNullsLast() {
    return (this._flags & NF.NullsLast) !== 0;
  }

  /**
   * Sets the sorting order to ascending (ASC).
   *
   * The same as calling `setSortOrder("ASC")`.
   *
   * @return {this}
   */
  ASC() {
    return this.replaceFlag(NF.Descending, NF.Ascending);
  }

  /**
   * Sets the sorting order to descending (DESC).
   *
   * The same as calling `setSortOrder("DESC")`.
   *
   * @return {this}
   */
  DESC() {
    return this.replaceFlag(NF.Ascending, NF.Descending);
  }

  /**
   * Specify `NULLS FIRST` clause.
   *
   * The same as calling `setNullsOrder("NULLS FIRST")`.
   *
   * @return {this}
   */
  NULLS_FIRST() {
    return this.replaceFlag(NF.NullsLast, NF.NullsFirst);
  }

  /**
   * Specify `NULLS LAST` clause.
   *
   * The same as calling `setNullsOrder("NULLS LAST")`.
   *
   * @return {this}
   */
  NULLS_LAST() {
    return this.replaceFlag(NF.NullsFirst, NF.NullsLast);
  }
}
xql$node.Sort = Sort;

function SORT(column, direction, nulls) {
  return new Sort(column, direction, nulls);
}
xql.SORT = SORT;

// ============================================================================
// [xql.Join]
// ============================================================================

/**
 * SQL join expression.
 *
 * @alias xql.node.Join
 */
class Join extends Binary {
  constructor(left, type, right, condition) {
    super(left, type, right, "");
    this._condition = condition;
  }

  /** @override */
  mustWrap(ctx, parent) {
    return false;
  }

  /** @override */
  compileNode(ctx) {
    return ctx._compileJoin(this);
  }

  /**
   * Gets the join condition.
   *
   * @return {Node|array}
   */
  getCondition() {
    return this._condition;
  }

  /**
   * Sets the join condition.
   *
   * @param {Node|array} condition A single node or array of nodes that form the
   *   condition.
   * @return {this}
   */
  setCondition(condition) {
    this._condition = condition;
    return this;
  }
}
xql$node.Join = Join;

// ============================================================================
// [xql.With]
// ============================================================================

class With extends Node {
  constructor(alias, statement) {
    super("WITH", alias)
    this._statement = statement;
  }

  /** @override */
  mustWrap(ctx, parent) {
    return false;
  }

  /** @override */
  compileNode(ctx) {
    const alias = this._alias;
    const statement = this._statement;

    const name = alias instanceof Node ? alias.compileNode(node)
                                       : ctx.escapeIdentifier(alias);
    if (!statement)
      throwCompileError("WITH requires a statement");

    return `${name} AS (` + ctx.concat(statement.compileNode(ctx)) + ctx._STR_OPT_NL + ")";
  }

  getStatement() {
    return this._statement;
  }

  setStatement(statement) {
    this._statement = statement;
  }
}
xql$node.With = With;

// ============================================================================
// [xql.Statement]
// ============================================================================

/**
 * SQL statement.
 */
class Statement extends Node {
  constructor(type) {
    super(type, "");
  }
};
xql$node.Statement = Statement;

// ============================================================================
// [xql.QueryStatement]
// ============================================================================

/**
 * SQL query statement.
 *
 * Query is a base class that provides basic blocks for implementing:
 *   - `SELECT` - See `SelectStatement`.
 *   - `INSERT` - See `InsertStatement`.
 *   - `UPDATE` - See `UpdateStatement`.
 *   - `DELETE` - See `DeleteStatement`.
 *   - `EXCEPT`, `INTERSECT`, and `UNION` - See `CompoundStatement`.
 *
 * The following features are implemented by the `QueryStatement`:
 *   - `TABLE`- Specifies a single database table.
 *   - `SELECT` or `RETURNING`- Specifies select or returning expression columns.
 *   - `WHERE` - Specifies `WHERE` clause.
 *
 * @param {string} type Type of the query.
 *
 * @alias xql.node.QueryStatement
 */
class QueryStatement extends Statement {
  constructor(type) {
    super(type, "");

    this._values = null;
    this._columns = null;

    // Used by:
    //   - SELECT - WITH ... AS (SELECT ...) SELECT
    this._with = NoArray;

    // Used by:
    //   - INSERT - INSERT INTO ...
    //   - UPDATE - UPDATE ...
    //   - DELETE - DELETE FROM ...
    this._table = null;

    // Used by:
    //   - SELECT - SELECT ...
    //   - INSERT - RETURNING ...
    //   - UPDATE - RETURNING ...
    //   - DELETE - RETURNING ...
    this._fieldsOrReturning = null;

    // Used by:
    //   - SELECT - FROM ...
    //   - UPDATE - FROM ...
    //   - DELETE - USING ...
    //
    // Contains the `FROM` or `USING` expression. The `_fromOrUsing` can be a
    // string describing a table name or `Node` that is describing a table name
    // with optional alias, `JOIN` expression, `VALUES` expression or `SELECT`
    // expression.
    this._fromOrUsing = null;

    // Used by:
    //   - SELECT
    //   - UPDATE
    //   - DELETE
    this._where = null;

    // Used by:
    //   - SELECT
    //   - EXCEPT, INTERSECT, UNION - See `CompoundStatement`.
    this._orderBy = null;

    // Used by:
    //   - SELECT
    //   - UPDATE
    //   - DELETE
    //
    // Contains "OFFSET ..." and "LIMIT ..." parameters. There are some DB engines
    // (like SQLite), which allow to specify OFFSET / LIMIT in `UPDATE` and DELETE.
    // This is the main reason that these members are part of QueryStatement and
    // not SelectStatement.
    this._offset = 0;
    this._limit = 0;

    // Optional type mapping having keys (columns) and their value types.
    //
    // Type mapping is sometimes important when it comes to type ambiguity. For
    // example when using PostgreSQL there is ambiguity when escaping `Array`.
    // It can be escaped by using PostgreSQL ARRAY[] or {} or as JSON [].
    this._typeMapping = null;

    this._flags |= NF.Statement;
  }

  /** @override */
  mustWrap(ctx, parent) {
    return parent != null;
  }

  getTypeMapping() {
    return this._typeMapping;
  }

  setTypeMapping(typeMapping) {
    this._typeMapping = typeMapping;
    return this;
  }

  _setFromOrIntoTable(table, keyword) {
    if (this._table)
      throwCompileError(keyword + "() - already specified ('" + table + "')");

    this._table = table;
    return this;
  }

  _addFieldsOrReturning(defs) {
    var fields = this._fieldsOrReturning;
    var i, len;

    // Handle multiple parameters.
    if (arguments.length > 1) {
      if (fields === null) {
        this._fieldsOrReturning = slice.call(arguments, 0);
        return this;
      }

      for (i = 0, len = arguments.length; i < len; i++)
        fields.push(arguments[i]);
      return this;
    }

    // Handle a single parameter of type `Object` or `Array`.
    if (typeof defs === "object") {
      // If the `defs` is array it should contain one or multiple columns. In
      // case that `_fieldsOrReturning` is `null` the given array `col` is used
      // instead of creating a copy of it.
      if (isArray(defs)) {
        if (fields === null) {
          this._fieldsOrReturning = defs;
          return this;
        }

        for (i = 0, len = defs.length; i < len; i++)
          fields.push(defs[i]);
        return this;
      }

      // If the `col` is not `Node` it is a dictionary where keys are columns
      // and values are either:
      //   1. `true` - describing the column of same name.
      //   2. `string` - describing unaliased name.
      //   3. `Node` - expression of that column.
      if (!(defs instanceof Node)) {
        if (fields === null)
          this._fieldsOrReturning = fields = [];

        for (var k in defs) {
          var def = defs[k];

          if (def === true) {
            fields.push(k);
            continue;
          }

          if (typeof def === "string")
            def = IDENT(def);

          fields.push(def.AS(k));
        }

        return this;
      }

      // ... Fall through ...
    }

    if (fields === null)
      this._fieldsOrReturning = [defs];
    else
      fields.push(defs);

    return this;
  }

  _addFromOrUsing(args) {
    var len = args.length;
    if (len < 1) return this;

    var arg = args[0];
    var left = this._fromOrUsing;

    if (left !== null)
      this._fromOrUsing = left = new Join(left, "", arg);
    else
      this._fromOrUsing = left = arg;

    if (len <= 1)
      return this;

    // Implicit `CROSS JOIN` syntax.
    var i = 1;
    do {
      arg = args[i];
      left = new Join(left, "", arg);
    } while (++i < len);

    this._fromOrUsing = left;
    return this;
  }

  // \function QueryStatement._join(type, with_, condition)
  _join(type, with_, condition) {
    var left = this._fromOrUsing;

    // Well this shouldn't be `null`.
    if (left === null)
      throwCompileError("QueryStatement._join() - There is no table to join with");

    this._fromOrUsing = new Join(left, type, with_, condition);
    return this;
  }

  // Add `WHERE` condition of specified `type`.
  _addWhere(type) {
    var node;
    var where = this._where;
    var aIsArray = false;
    var a, b, c, op;

    switch (arguments.length) {
      case 2:
        a = arguments[1];
        aIsArray = isArray(a);
        if (!aIsArray)
          node = (a instanceof Node) ? a : new ConditionMap("AND", a);
        break;

      case 3:
        a = arguments[1];
        b = arguments[2];
        if (typeof a === "string")
          a = IDENT(a);
        node = BINARY_OP(a, "=", b);
        break;

      case 4:
        a  = arguments[1];
        op = arguments[2];
        b  = arguments[3];
        if (typeof a === "string")
          a = IDENT(a);
        node = BINARY_OP(a, op, b);
        break;

      case 5:
        // This was added to only support "BETWEEN" and "NOT BETWEEN" directly
        // in "WHERE" condition. We don't accept anything else.
        a  = arguments[1];
        op = arguments[2];
        b  = arguments[3];
        c  = arguments[4];

        if (op != "BETWEEN" && op != "NOT BETWEEN")
          throwTypeError(`QueryStatement.${type} doesn't support '${op}' operator, build the expression instead`);

        node = new Func(op, [a, b, c]);
        break;

      default:
        throwTypeError(`QueryStatement.${type} doesn't accept ${arguments.length-1} arguments, only 1-4 accepted`);
    }

    if (where === null) {
      // If no `WHERE` has been added yet, create one.
      where = new Logical(type);
      this._where = where;
    }
    else if (where._type !== type) {
      // If the current expression operator is not the same as `type`,
      // wrap the current expression inside a new binary-op node.
      where = new Logical(type);
      where.push(this._where);
      this._where = where;
    }

    if (aIsArray)
      where.concat(a);
    else
      where.push(node);

    return this;
  }

  /**
   * Add WITH clause (or multiple clauses) to the query.
   */
  WITH() {
    if (arguments.length === 1) {
      const arg = arguments[0];
      if (!isArray(arg)) {
        if (this._with === NoArray)
          this._with = [arg];
        else
          this._with.push(arg);
      }
      else {
        if (this._with === NoArray)
          this._with = arg;
        else
          this._with.push(...arg);
      }
      return this;
    }

    if (arguments.length === 2) {
      const node = new With(arguments[0], arguments[1]);

      if (this._with === NoArray)
        this._with = [node];
      else
        this._with.push(node);
      return this;
    }

    throwTypeError("Invalid number of arguments passed to xql.QueryStatement.WITH()");
  }

  /**
   * Add values to the query.
   *
   * @param {object|object[]} data Values as object or an array of objects.
   * @return {this}
   */
  VALUES(data) {
    var values = this._values;
    var columns = this._columns;

    var dataIsArray = isArray(data);
    if (dataIsArray && data.length === 0)
      return this;

    if (values === null) {
      this._values = values = [];
      this._columns = columns = {};
    }

    var object, k;
    if (dataIsArray) {
      // Array of objects.
      for (var i = 0, len = data.length; i < len; i++) {
        object = data[i];
        values.push(object);

        for (k in object)
          columns[k] = true;
      }
    }
    else {
      object = data;
      values.push(object);

      for (k in object)
        columns[k] = true;
    }

    return this;
  }

  /**
   * Adds a `WHERE` expression to the query (implicit `AND`).
   *
   * This function has multiple overloads:
   *
   * 1. `where(node:xql.Node)`
   *   Node that contains an expression.
   *
   * 2. `where(keys:object)`
   *   Object that contain key/value pairs that will be checked for equality,
   *   implicit `AND` will be added to the query between all keys specified.
   *   Objects without keys are ignored.
   *
   * 3. `where(a:string, b:*)`
   *   Adds one `WHERE` clause in the form `a = b`.
   *
   * 4. `where(a:string, op:string, b:*)`
   *   Adds one `WHERE` clause in the form `a op b`.
   *
   * @param {...*} args Variable arguments.
   * @return {this}
   */
  WHERE() {
    return this._addWhere("AND", ...arguments);
  }

  /**
   * Adds a `WHERE` expression to the query (implicit `OR`).
   *
   * This function is similar to `WHERE`, however, instead of forming a logical
   * `AND` it forms a logical `OR`. See {@link WHERE} for more details.
   *
   * @param {...*} args Variable arguments.
   * @return {this}
   */
  OR_WHERE() {
    return this._addWhere("OR", ...arguments);
  }

  /**
   * Adds an `ORDER BY` clause to the query.
   *
   * The first parameter `column` can specify a single column or multiple
   * columns: `ORDER_BY(["name"])` and `ORDER_BY("name")` are equivalent.
   *
   * @param {array|string|Identifier} column A single column or an array of
   *   columns.
   * @param {string} [order] Sorting order.
   *   Can contain either "" (default), "ASC", or "DESC".
   * @param {string} [nulls] Sorting nulls option.
   *   Can contain either "" (default), "NULLS FIRST", or "NULLS LAST".
   * @return {this}
   */
  ORDER_BY(column, order, nulls) {
    var orderBy = this._orderBy;

    if (orderBy === null)
      orderBy = this._orderBy = [];

    if (isArray(column)) {
      var columns = column;
      var len = columns.length;

      if (!len)
        return this;

      for (var i = 0; i < len; i++) {
        column = columns[i];
        orderBy.push(new Sort(column, order, nulls));
      }
    }
    else {
      orderBy.push(new Sort(column, order, nulls));
    }

    return this;
  }

  /**
   * Sets the `OFFSET` clause.
   *
   * @param {?number} offset SQL query offset.
   * @return {this}
   */
  OFFSET(offset) {
    this._offset = offset;
    return this;
  }

  /**
   * Sets the `LIMIT` clause.
   *
   * @param {?number} offset SQL query limit.
   * @return {this}
   */
  LIMIT(limit) {
    this._limit = limit;
    return this;
  }
}
xql$node.QueryStatement = QueryStatement;

// ============================================================================
// [xql.SelectStatement]
// ============================================================================

/**
 * SQL select.
 *
 * @alias xql.node.SelectStatement
 */
class SelectStatement extends QueryStatement {
  constructor() {
    super("SELECT");

    this._flags |= NF.All;

    // DISTINCT ON (...) clause.
    this._distinct = null;

    // GROUP BY clause.
    this._groupBy = null;

    // HAVING clause.
    this._having = null;
  }

  /** @override */
  mustWrap(ctx, parent) {
    // If this is a sub-select that will be compiled as `(SELECT ???) AS something` then we
    // will wrap it during compilation and return `false` here so it's not double-wrapped.
    return parent != null && !(parent instanceof CompoundStatement);
  }

  /** @override */
  compileNode(ctx) {
    return ctx._compileSelect(this);
  }

  /**
   * Unfortunately this is the same as `_addFieldsOrReturning()` but using a
   * `_distinct` member for storing the expressions.
   */
  _addDistinct(defs) {
    var fields = this._distinct;
    var i, len;

    if (arguments.length > 1) {
      if (fields === null) {
        this._distinct = slice.call(arguments, 0);
        return this;
      }

      for (i = 0, len = arguments.length; i < len; i++)
        fields.push(arguments[i]);
      return this;
    }

    // Handle a single parameter of type `Object` or `Array`.
    if (typeof defs === "object") {
      if (isArray(defs)) {
        if (fields === null) {
          this._distinct = defs;
          return this;
        }

        for (i = 0, len = defs.length; i < len; i++)
          fields.push(defs[i]);
        return this;
      }

      if (!(defs instanceof Node)) {
        if (fields === null)
          this._distinct = fields = [];

        for (var k in defs) {
          var def = defs[k];

          if (def === true) {
            fields.push(k);
            continue;
          }

          if (typeof def === "string")
            def = IDENT(def);

          fields.push(def.AS(k));
        }

        return this;
      }

      // ... Fall through ...
    }

    if (fields === null)
      this._distinct = [defs];
    else
      fields.push(defs);

    return this;
  }

  // Add `HAVING` condition of specified `type`.
  _addHaving(type, a, op, b, nArgs) {
    var node;
    var having = this._having;
    var aIsArray = false;

    // Accept 1, 2 or 3 arguments.
    if (nArgs >= 2) {
      if (typeof a === "string")
        a = IDENT(a);
      if (nArgs === 2)
        node = BINARY_OP(a, "=", op);
      else
        node = BINARY_OP(a, op, b);
    }
    else if (nArgs !== 1) {
      throwCompileError((type === "OR" ? "OR_" : "") + "HAVING - Invalid argument");
    }
    else {
      aIsArray = isArray(a);
      if (!aIsArray)
        node = (a instanceof Node) ? a : new ConditionMap("AND", a);
    }

    // If no `HAVING` has been added yet, create one.
    if (having === null) {
      having = new Logical(type);
      this._having = having;
    }
    // If the current expression operator is not the same as `type`, wrap the
    // current expression inside a new `Node`.
    else if (having._type !== type) {
      having = new Logical(type);
      having.push(this._having);
      this._having = having;
    }

    if (aIsArray)
      having.concat(a);
    else
      having.push(node);

    return this;
  }

  /**
   * Sets the `ALL` option and optionally add fields to the query.
   *
   * It accepts the same arguments as `SELECT()` so it can be used in a similar
   * way.
   *
   * @param {...*} args Variable arguments.
   * @return {this}
   */
  ALL() {
    this.replaceFlag(NF.Distinct, NF.All);
    if (arguments.length)
      this.FIELD.apply(this, arguments);
    return this;
  }

  /**
   * Sets the `DISTINCT` option and optionally add fields to the query.
   *
   * It accepts the same arguments as `SELECT()` so it can be used in a similar
   * way. The following expressions are equivalent:
   *
   *   ```
   *   SELECT(["a", "b", "c"]).DISTINCT()
   *   SELECT().DISTINCT().FIELD(["a", "b", "c"])
   *   ```
   *
   * Please note that use can also use DISTINCT(arguments), however, if
   * you use such construct it means that instead of DISTINCT you want a
   * DISTINCT ON expression, which explicitly specifies which columns
   * must be checked for duplicates.
   *
   *   `SELECT().DISTINCT(["a", "b").FIELD(["a", "b", "c")`
   *
   * Would yield:
   *
   *   `SELECT DISTINCT ON ("a", "b") "a", "b", "c"`
   *
   * @param {...*} args Variable arguments.
   * @return {this}
   */
  DISTINCT(...args) {
    this.replaceFlag(NF.All, NF.Distinct);
    if (args.length)
      this._addDistinct(...args);
    return this;
  }

  /**
   * Specifies the `FROM` table (or list of tables).
   *
   * The function has the following signatures:
   *
   *   1. `FROM(table:string)` - Specifies a single table.
   *   2. `FROM(table1, table2, ...)` - Specifies multiply tables that forms
   *      an implicit CROSS JOIN.
   *   3. `FROM([array])` - Like the second form, but the tables are specified
   *      by the array passed in the first argument.
   *
   * @param {...*} args Variable arguments
   */
  FROM() {
    var arg;
    if (arguments.length === 1 && isArray((arg = arguments[0])))
      return this._addFromOrUsing(arg);
    else
      return this._addFromOrUsing(slice.call(arguments, 0));
  }

  /**
   * Adds a `CROSS JOIN` expression to the query.
   *
   * @param {string} with_ Specifies the table to join with.
   * @param {*} condition Specifies join condition.
   * @return {this}
   */
  CROSS_JOIN(with_, condition) {
    return this._join("CROSS", with_, condition);
  }

  /**
   * Adds an `INNER JOIN` expression to the query.
   *
   * @param {string} with_ Specifies the table to join with.
   * @param {*} condition Specifies join condition.
   * @return {this}
   */
  INNER_JOIN(with_, condition) {
    return this._join("INNER", with_, condition);
  }

  /**
   * Adds a `LEFT OUTER JOIN` expression to the query.
   *
   * @param {string} with_ Specifies the table to join with.
   * @param {*} condition Specifies join condition.
   * @return {this}
   */
  LEFT_JOIN(with_, condition) {
    return this._join("LEFT", with_, condition);
  }

  /**
   * Adds a `RIGHT OUTER` join expression to the query.
   *
   * @param {string} with_ Specifies the table to join with.
   * @param {*} condition Specifies join condition.
   * @return {this}
   */
  RIGHT_JOIN(with_, condition) {
    return this._join("RIGHT", with_, condition);
  }

  /**
   * Adds a `FULL OUTER JOIN` expression to the query.
   *
   * @param {string} with_ Specifies the table to join with.
   * @param {*} condition Specifies join condition.
   * @return {this}
   */
  FULL_JOIN(with_, condition) {
    return this._join("FULL", with_, condition);
  }

  // \function SelectStatement.GROUP_BY(...)
  GROUP_BY(arg) {
    var groupBy = this._groupBy;
    var i, len;

    if (arguments.length > 1) {
      if (groupBy === null) {
        this._groupBy = slice.call(arguments, 0);
      }
      else {
        for (i = 0, len = arguments.length; i < len; i++)
          groupBy.push(arguments[i]);
      }
    }
    else if (isArray(arg)) {
      // Optimization: If `_groupBy` is `null` the given array `arg` is referenced.
      if (groupBy === null) {
        this._groupBy = arg;
      }
      else {
        for (i = 0, len = arg.length; i < len; i++)
          groupBy.push(arg[i]);
      }
    }
    else {
      if (groupBy === null)
        this._groupBy = [arg];
      else
        groupBy.push(arg);
    }

    return this;
  }

  // \function SelectStatement.FIELD(...)

  // \function SelectStatement.HAVING(...)
  HAVING(a, op, b) {
    return this._addHaving("AND", a, op, b, arguments.length);
  }

  // \function SelectStatement.OR_HAVING(...)
  OR_HAVING(a, op, b) {
    return this._addHaving("OR", a, op, b, arguments.length);
  }
}
xql$node.SelectStatement = alias(SelectStatement, {
  FIELD: "_addFieldsOrReturning"
});

/**
 * Constructs a SELECT query.
 *
 * @param {...*} fields Fields can be specified in several ways. This parameter
 *   is passed as is into `SelectStatement.FIELDS()` function.
 * @return {SelectStatement}
 *
 * @alias xql.SELECT
 */
function SELECT(...args) {
  var q = new SelectStatement();
  if (args.length)
    q.FIELD(...args);
  return q;
}
xql.SELECT = SELECT;

// ============================================================================
// [xql.InsertStatement]
// ============================================================================

/**
 * SQL insert.
 *
 * @alias xql.node.InsertStatement
 */
class InsertStatement extends QueryStatement {
  constructor() {
    super("INSERT");
  }

  /** @override */
  compileNode(ctx) {
    return ctx._compileInsert(this);
  }

  // \function InsertStatement.TABLE(table)
  //
  // Alias to `InsertStatement.INTO(table)`.
  TABLE(table) {
    return this._setFromOrIntoTable(table, "TABLE");
  }

  // \function InsertStatement.INTO(table)
  INTO(table) {
    return this._setFromOrIntoTable(table, "INTO");
  }

  // \function InsertStatement.RETURNING(...)
}
xql$node.InsertStatement = alias(InsertStatement, {
  RETURNING: "_addFieldsOrReturning"
});

/**
 * Constructs an INSERT query.
 *
 * @param {...*} args
 * @return {InsertStatement}
 *
 * @alias xql.INSERT
 */
function INSERT(/* ... */) {
  var q = new InsertStatement();

  var i = 0, len = arguments.length;
  var arg;

  // If the first parameter is a string or an identifier it is a table name.
  if (i < len) {
    arg = arguments[i];
    if (typeof arg === "string" || arg instanceof Identifier) {
      q._table = arg;
      i++;
    }
  }

  // Next arguments can contain data (array/object) to insert.
  while (i < len) {
    arg = arguments[i++];
    q.VALUES(arg);
  }

  return q;
}
xql.INSERT = INSERT;

// ============================================================================
// [xql.UpdateStatement]
// ============================================================================

/**
 * SQL update.
 *
 * @alias xql.node.UpdateStatement
 */
class UpdateStatement extends QueryStatement {
  constructor() {
    super("UPDATE");
  }

  /** @override */
  compileNode(ctx) {
    return ctx._compileUpdate(this);
  }

  // \function UpdateStatement.TABLE(table)
  TABLE(table) {
    return this._setFromOrIntoTable(table, "TABLE");
  }

  // \function UpdateStatement.FROM(...)
  FROM(table) {
    return this._setFromOrIntoTable(table, "FROM");
  }

  // \function UpdateStatement.RETURNING(...)
}
xql$node.UpdateStatement = alias(UpdateStatement, {
  RETURNING: "_addFieldsOrReturning"
});

/**
 * Constructs an UPDATE query.
 *
 * @param {...*} args
 * @return {UpdateStatement}
 *
 * @alias xql.UPDATE
 */
function UPDATE(/* ... */) {
  var q = new UpdateStatement();

  var i = 0, len = arguments.length;
  var arg;

  // If the first parameter is a string or an identifier it is a table name.
  if (i < len) {
    arg = arguments[i];
    if (typeof arg === "string" || arg instanceof Identifier) {
      q._table = arg;
      i++;
    }
  }

  // Next argument can contain data to update.
  if (i < len) {
    arg = arguments[i];
    q.VALUES(arg);
  }

  // TODO: What if more arguments are passed.

  return q;
}
xql.UPDATE = UPDATE;

// ============================================================================
// [xql.DeleteStatement]
// ============================================================================

/**
 * SQL delete.
 *
 * @alias xql.node.DeleteStatement
 */
class DeleteStatement extends QueryStatement {
  constructor() {
    super("DELETE");
  }

  /** @override */
  compileNode(ctx) {
    return ctx._compileDelete(this);
  }

  // \function DeleteStatement.TABLE(table)
  //
  // Alias to `DeleteStatement.FROM(table)`.

  // \function DeleteStatement.FROM(table)

  // \function DeleteStatement.RETURNING(...)

  // \function DeleteStatement.USING(...)
  USING() {
    var arg;
    if (arguments.length === 1 && isArray((arg = arguments[0])))
      return this._addFromOrUsing(arg);
    else
      return this._addFromOrUsing(slice.call(arguments, 0));
  }
}
xql$node.DeleteStatement = alias(DeleteStatement, {
  FROM     : "_setFromOrIntoTable",
  TABLE    : "_setFromOrIntoTable",
  RETURNING: "_addFieldsOrReturning"
});

/**
 * Constructs a DELETE query.
 *
 * @param {string} [from] SQL table where to delete records.
 * @return {DeleteStatement}
 *
 * @alias xql.DELETE
 */
function DELETE(from) {
  var q = new DeleteStatement();
  if (from)
    q._table = from;
  return q;
}
xql.DELETE = DELETE;

// ============================================================================
// [xql.CompoundStatement]
// ============================================================================

/**
 * SQL combining query/operator (UNION, INTERSECT, EXCEPT).
 *
 * @alias xql.node.CompoundStatement
 */
class CompoundStatement extends QueryStatement {
  constructor(type, values) {
    super(type);

    this._flags |= NF.Distinct;
    this._values = values || [];
  }

  /** @override */
  mustWrap(ctx, parent) {
    return parent != null && parent._type !== this._type;
  }

  /** @override */
  compileNode(ctx) {
    return ctx._compileCompound(this);
  }

  /**
   * Sets the `ALL` option of the query (and clears the `DISTINCT` option).
   *
   * @return {this}
   */
  ALL() {
    return this.replaceFlag(NF.Distinct, NF.All);
  }

  /**
   * Sets the `DISTINCT` option of the query (and clears the `ALL` option).
   *
   * @return {this}
   */
  DISTINCT() {
    return this.replaceFlag(NF.All, NF.Distinct);
  }

  push() {
    var values = this._values;
    values.push.apply(values, arguments);
    return this;
  }

  concat(array) {
    var values = this._values;
    for (var i = 0, len = array.length; i < len; i++)
      values.push(array[i]);
    return this;
  }
}
xql$node.CompoundStatement = CompoundStatement;

/**
 * Constructs an `EXCEPT` expression.
 *
 * @param {...*} args Arguments passed as an array or as `...args`.
 *   Arguments must be SQL queries that form the EXCEPT expression.
 * @return {CompoundStatement}
 *
 * @alias xql.EXCEPT
 */
function EXCEPT(array) {
  return new CompoundStatement("EXCEPT", isArray(array) ? array : slice.call(arguments, 0));
}
xql.EXCEPT = EXCEPT;

/**
 * Shorthand for `EXCEPT(...args).ALL()`.
 *
 * @param {...*} args Arguments passed as an array or as `...args`.
 * @return {CompoundStatement}
 *
 * @see EXCEPT
 * @see CompoundStatement.prototype.ALL
 *
 * @alias xql.EXCEPT_ALL
 */
function EXCEPT_ALL(array) {
  return new CompoundStatement("EXCEPT", isArray(array) ? array : slice.call(arguments, 0)).ALL();
}
xql.EXCEPT_ALL = EXCEPT_ALL;

/**
 * Constructs an `INTERSECT` expression.
 *
 * @param {...*} args Arguments passed as an array or as `...args`.
 *   Arguments must be SQL queries that form the INTERSECT expression.
 * @return {CompoundStatement}
 *
 * @alias xql.INTERSECT
 */
function INTERSECT(array) {
  return new CompoundStatement("INTERSECT", isArray(array) ? array : slice.call(arguments, 0));
}
xql.INTERSECT = INTERSECT;

/**
 * Shorthand for `INTERSECT(...args).ALL()`.
 *
 * @param {...*} args Arguments passed as an array or as `...args`.
 * @return {CompoundStatement}
 *
 * @see INTERSECT
 * @see CompoundStatement.prototype.ALL
 *
 * @alias xql.INTERSECT_ALL
 */
function INTERSECT_ALL(array) {
  return new CompoundStatement("INTERSECT", isArray(array) ? array : slice.call(arguments, 0)).ALL();
}
xql.INTERSECT_ALL = INTERSECT_ALL;

/**
 * Constructs a `UNION` expression.
 *
 * @param {...*} args Arguments passed as an array or as `...args`.
 *   Arguments must be SQL queries that form the UNION expression.
 * @return {CompoundStatement}
 *
 * @alias xql.UNION
 */
function UNION(array) {
  return new CompoundStatement("UNION", isArray(array) ? array : slice.call(arguments, 0));
}
xql.UNION = UNION;

/**
 * Shorthand for `UNION(...args).ALL()`.
 *
 * @param {...*} args Arguments passed as an array or as `...args`.
 * @return {CompoundStatement}
 *
 * @see UNION
 * @see CompoundStatement.prototype.ALL
 *
 * @alias xql.UNION_ALL
 */
function UNION_ALL(array) {
  return new CompoundStatement("UNION", isArray(array) ? array : slice.call(arguments, 0)).ALL();
}
xql.UNION_ALL = UNION_ALL;

// ============================================================================
// [xql.VALUE]
// ============================================================================

(function() {

const ValueTypes = {
  VALUE      : "",
  VALUES     : "VALUES",
  DATE       : "DATE",
  TIME       : "TIME",
  TIMESTAMP  : "TIMESTAMP",
  TIMESTAMPTZ: "TIMESTAMPTZ",
  INTERVAL   : "INTERVAL",
  ARRAY      : "ARRAY",
  JSON_      : "JSON",
  JSONB      : "JSONB"
};

for (var k in ValueTypes)
  xql[k] = Value.makeWrap(ValueTypes[k]);

// Mostly backwards compatibility and some people's preference.
xql.VAL = xql.VALUE;

})();

// ============================================================================
// [xql.FUNC]
// ============================================================================

(function() {

const N = -1;

function register(defs, commons) {
  const baseOpFlags  = commons.opFlags  || 0;
  const baseCategory = commons.category || "core";
  const baseDialect  = commons.dialect  || "*";

  for (var i = 0; i < defs.length; i++) {
    const def = defs[i];

    var name     = def.name;
    var nameNot  = null;
    var args     = def.args;
    var opFlags  = (def.opFlags || 0) | baseOpFlags;
    var dialect  = def.dialect  || baseDialect;
    var category = def.category || baseCategory;

    if (name.indexOf("[NOT]") !== -1) {
      nameNot = name.replace("[NOT]", "NOT");
      name = name.replace("[NOT]", "").trim();
    }

    var format = (opFlags & OF.SpaceSeparate) ? " " + name + " " : name;
    var formatNot = nameNot ? ((opFlags & OF.SpaceSeparate) ? " " + nameNot + " " : nameNot) : null;

    var ctor = def.ctor;
    if (!ctor)
      ctor = (opFlags & OF.Unary   ) ? Unary  :
             (opFlags & OF.Binary  ) ? Binary :
             (opFlags & OF.Function) ? Func   : null;

    if (!ctor)
      throwTypeError("Cannot guess constructor as nothing is specified in 'opFlags'");

    OpInfo.add({
      name      : name,
      nameNot   : nameNot,
      format    : format,
      formatNot : formatNot,
      doc       : def.doc || "",
      ctor      : ctor,
      opFlags   : opFlags,
      nodeFlags : 0,
      dialect   : dialect,
      category  : category,
      minArgs   : isArray(args) ? args[0] : args,
      maxArgs   : isArray(args) ? args[1] : args,
      compile   : def.compile || null
    });
  }
}

function asDateTimePartName(ctx, value) {
  const part = value instanceof Value ? value._value : value;

  if (typeof part !== "string")
    throwCompileError(`Expected a date-time part name, which must be a string, not '${typeof part}'`);

  const partUpper = part.toUpperCase();
  if (!hasOwn.call(DateFieldMap, partUpper))
    throwCompileError(`Expected a date-time part name, '${part}' doesn't match`);

  return partUpper;
}

function compileCast(ctx, $) {
  const args = $._values;
  return "CAST(" + ctx._compile(args[0]) + " AS " + ctx._compile(args[1]) + ")";
}

function compileBetween(ctx, $) {
  const args = $._values;
  const info = OpInfo.get($._type);
  const keyword = ($._flags & NF.Not) ? info.formatNot : info.format;

  return ctx.escapeOrWrap(args[0]) + keyword +
         ctx.escapeOrWrap(args[1]) + " AND " +
         ctx.escapeOrWrap(args[2]);
}

function compileAtan(ctx, $) {
  const args = $._values;
  return ctx._compileFuncImpl(args.length <= 1 ? "ATAN" : "ATAN2", args, $._flags, $._alias);
}

function compileLog10(ctx, $) {
  if (ctx.dialect !== "mysql")
    return ctx._compileFuncImpl("LOG", [10, $._values[0]], $._flags, $._alias);
  else
    return ctx._compileFuncImpl("LOG10", $._values, $._flags, $._alias);
}

function compileLog2(ctx, $) {
  if (ctx.dialect !== "mysql")
    return ctx._compileFuncImpl("LOG", [2, $._values[0], $._flags, $._alias]);
  else
    return ctx._compileFuncImpl("LOG2", $._values, $._flags, $._alias);
}

function compileRandom(ctx, $) {
  if (ctx.dialect === "mysql")
    return ctx._compileFuncImpl("RAND", $._values, $._flags, $._alias);
  else
    return ctx._compileFuncImpl("RANDOM", $._values, $._flags, $._alias);
}

function compileTrunc(ctx, $) {
  var name = $._type;
  var args = $._values;

  if (ctx.dialect === "mysql") {
    name = "TRUNCATE";
    if (args.length === 1)
      args = args.concat(0);
  }

  return ctx._compileFuncImpl(name, args, $._flags, $._alias);
}

function compileGreatestLeast(ctx, $) {
  var name = $._type;
  var args = $._values;

  var n = args.length;
  if (n <= 1)
    return n === 1 ? "(" + ctx._compile(args[0]) + ")" : "NULL";

  switch (ctx.features.leastGreatest) {
    case "MIN|MAX": {
      name = name === "LEAST" ? "MIN" : "MAX";
      break;
    }

    case "IIF": {
      var sign = name === "LEAST" ? "<" : ">";
      if (n > 2)
        throwCompileError(`Cannot replace '${name}' of ${n} arguments with 'IIF'`);

      const a = ctx._compile(args[0]);
      const b = ctx._compile(args[1]);
      return `IIF((${a}) ${sign} (${b}), ${a}, ${b})`;
    }
  }

  // Implements either LEAST|GREATEST or MIN|MAX approach.
  return ctx._compileFuncImpl(name, args, $._flags, $._alias);
}

function compileChr(ctx, $) {
  var name = $._type;
  var args = $._values;

  if (ctx.dialect === "mysql")
    return ctx._compileFuncImpl("CHAR", args, $._flags, $._alias);
  else
    return ctx._compileFuncImpl(name, args, $._flags, $._alias);
}

function compileOverlay(ctx, $) {
  var name = $._type;
  var args = $._values;

  if (args.length < 3 || args.length > 4)
    throwCompileError(`OVERLAY must have between 3-4 arguments, ${args.length} given'`);

  var body = ctx._compile(args[0]) +
             " PLACING " + ctx._compile(args[1]) +
             " FROM "    + ctx._compile(args[2]);

  if (args.length >= 4)
    body += " FOR " + ctx._compile(args[3]);

  return ctx._compileFuncAs(`OVERLAY(${body})`, $._alias);
}

function compilePosition(ctx, $) {
  var args = $._values;
  if (args.length !== 2)
    throwCompileError(`POSITION must have 2 arguments, ${args.length} given'`);

  var body = ctx._compile(args[0]) + " IN " + ctx._compile(args[1]);
  return ctx._compileFuncAs(`POSITION(${body})`, $._alias);
}

function compileSubString(ctx, $) {
  var args = $._values;
  if (args.length < 1 || args.length > 3)
    throwCompileError(`SUBSTRING must have between 2-3 arguments, ${args.length} given'`);

  var body = ctx._compile(args[0]) +
             (args.length > 1 ? " FROM " + ctx._compile(args[1]) : " FROM 0");

  if (args.length > 2)
    body += " FOR " + ctx._compile(args[2]);

  return ctx._compileFuncAs(`SUBSTRING(${body})`, $._alias);
}

function compileBTrim(ctx, $) {
  var args = $._values;
  if (args.length < 1 || args.length > 2)
    throwCompileError(`BTRIM must have between 1-2 arguments, ${args.length} given'`);

  if (ctx.dialect === "sqlite") {
    // Compile to "TRIM" as it has the same semantics as BTRIM.
    return ctx._compileFuncImpl("TRIM", args, $._flags, $._alias);
  }
  else if (ctx.dialect === "pgsql") {
    // Compile to "BTRIM" as it matches our semantics.
    return ctx._compileFuncImpl("BTRIM", args, $._flags, $._alias);
  }
  else if (ctx.dialect === "mssql") {
    // Compile BTRIM into "LTRIM(RTRIM(...) [, ...])"
    var exp = ctx._compile(args[0]);
    var opt = args.length > 1 ? ", " + ctx._compile(args[1]) : "";
    return ctx._compileFuncAs(`LTRIM(RTRIM(${exp}${opt})${opt})`, $._alias);
  }
  else {
    // Compile to a standard SQL "TRIM(characters FROM expression)".
    var body = "";
    if (args.length === 1)
      body = `TRIM(${ctx._compile(args[0])})`;
    else
      body = `TRIM(${ctx._compile(args[1])} FROM ${ctx._compile(args[0])})`;
    return ctx._compileFuncAs(body, $._alias);
  }
}

function compileNow(ctx, $) {
  var name = $._type;
  var args = $._values;

  if (ctx.dialect === "sqlite")
    return ctx._compileFuncAs(`CURRENT_TIMESTAMP`, $._alias);

  return ctx._compileFuncImpl(name, args, $._flags, $._alias);
}

function compileCurrentDateTime(ctx, $) {
  var name = $._type;
  var args = $._values;

  if (ctx.dialect === "sqlite") {
    switch (name) {
      case "NOW"           : return ctx._compileFuncAs(`CURRENT_TIMESTAMP`, $._alias);
      case "LOCALTIME"     : return ctx._compileFuncAs(`TIME('now', 'localtime')`, $._alias);
      case "LOCALTIMESTAMP": return ctx._compileFuncAs(`DATETIME('now','localtime')`, $._alias);
    }
  }

  if (args.length === 0 && ctx.dialect !== "mysql")
    return name;

  return ctx._compileFuncImpl(name, args, $._flags, $._alias);
}

function compileExtract(ctx, $) {
  var name = $._type;
  var args = $._values;

  if (args.length !== 2)
    throwCompileError(`Function '${name}' expects 2 arguments, ${args.length} given`);

  var part = asDateTimePartName(ctx, args[0]);
  var body = name + "(" + part + " FROM " + ctx._compile(args[1]) + ")";
  return ctx._compileFuncAs(body, $._alias);
}

register([
  { name: "NOT"                      , args: 1     , dialect: "*"     , doc: "NOT($1)" },
  { name: "[NOT] EXISTS"             , args: 1     , dialect: "*"     , doc: "EXISTS($1)" }
], { category: "general", opFlags: OF.Unary });

register([
  { name: "="                        , args: 2     , dialect: "*"     },
  { name: ">"                        , args: 2     , dialect: "*"     },
  { name: ">="                       , args: 2     , dialect: "*"     },
  { name: "<"                        , args: 2     , dialect: "*"     },
  { name: "<="                       , args: 2     , dialect: "*"     },
  { name: "<>"                       , args: 2     , dialect: "*"     },
  { name: "@>"                       , args: 2     , dialect: "*"      , doc: "Contains"               },
  { name: "<@"                       , args: 2     , dialect: "*"      , doc: "Contained by"           },
  { name: "&&"                       , args: 2     , dialect: "*"      , doc: "Overlap"                },
  { name: "&<"                       , args: 2     , dialect: "*"      , doc: "Right of"               },
  { name: "&>"                       , args: 2     , dialect: "*"      , doc: "Left of"                },
  { name: "-|-"                      , args: 2     , dialect: "*"      , doc: "Adjacent to"            },
  { name: "+"                        , args: 2     , dialect: "*"      , doc: "Add / Union"            },
  { name: "-"                        , args: 2     , dialect: "*"      , doc: "Subtract / Difference"  },
  { name: "*"                        , args: 2     , dialect: "*"      , doc: "Multiply / Intersect"   },
  { name: "/"                        , args: 2     , dialect: "*"      , doc: "Divide"                 },
  { name: "%"                        , args: 2     , dialect: "*"      , doc: "Modulo"                 },
  { name: "^"                        , args: 2     , dialect: "pgsql"  , doc: "Power"                  },
  { name: "&"                        , args: 2     , dialect: "*"      , doc: "Bitwise AND"            },
  { name: "|"                        , args: 2     , dialect: "*"      , doc: "Bitwise OR"             },
  { name: "#"                        , args: 2     , dialect: "*"      , doc: "Bitwise XOR"            },
  { name: "~"                        , args: 2     , dialect: "*"      , doc: "Bitwise NOT / Match"    },
  { name: "<<"                       , args: 2     , dialect: "*"      , doc: "Left shift / Left of"   },
  { name: ">>"                       , args: 2     , dialect: "*"      , doc: "Right shift / Right of" },
  { name: "||"                       , args: 2     , dialect: "*"      , doc: "Concatenate"            },
  { name: "~*"                       , args: 2     , dialect: "*"      , doc: "Match (I)"              },
  { name: "!~"                       , args: 2     , dialect: "*"      , doc: "Not match"              },
  { name: "!~*"                      , args: 2     , dialect: "*"      , doc: "Not match (I)"          }
], { category: "general", opFlags: OF.Binary | OF.SpaceSeparate });

register([
  { name: "IS [NOT]"                 , args: 2     , dialect: "*"     },
  { name: "IS [NOT] DISTINCT FROM"   , args: 2     , dialect: "*"     },
  { name: "[NOT] LIKE"               , args: 2     , dialect: "*"     },
  { name: "[NOT] ILIKE"              , args: 2     , dialect: "*"     },
  { name: "[NOT] SIMILAR TO"         , args: 2     , dialect: "*"     }
], { category: "general", opFlags: OF.Binary | OF.SpaceSeparate });

register([
  { name: "[NOT] IN"                 , args: 2     , dialect: "*"     }
], { category: "general", opFlags: OF.Binary | OF.SpaceSeparate | OF.RightValues});

register([
  { name: "AND"                      , args: 2     , dialect: "*"     },
  { name: "OR"                       , args: 2     , dialect: "*"     }
], { category: "general", opFlags: OF.Binary | OF.SpaceSeparate });

register([
  { name: "OVERLAPS"                 , args: 2     , dialect: "*"     }
], { category: "datetime", opFlags: OF.Binary | OF.SpaceSeparate });

register([
  { name: "[NOT] BETWEEN"            , args: 3     , dialect: "*"      , compile: compileBetween },
  { name: "[NOT] BETWEEN SYMMETRIC"  , args: 3     , dialect: "*"      , compile: compileBetween }
], { category: "general", opFlags: OF.Function | OF.SpaceSeparate });

register([
  { name: "CAST"                     , args: 2     , dialect: "*"      , compile: compileCast },
  { name: "NULLIF"                   , args: 2     , dialect: "*"     },
  { name: "COALESCE"                 , args: [1, N], dialect: "*"     },
  { name: "GREATEST"                 , args: [1, N], dialect: "*"      , compile: compileGreatestLeast },
  { name: "LEAST"                    , args: [1, N], dialect: "*"      , compile: compileGreatestLeast },
  { name: "NUM_NULLS"                , args: [0, N], dialect: "*"     },
  { name: "NUM_NONNULLS"             , args: [0, N], dialect: "*"     }
], { category: "general", opFlags: OF.Function });

register([
  { name: "ABS"                      , args: 1     , dialect: "*"     },
  { name: "ACOS"                     , args: 1     , dialect: "*"     },
  { name: "ASIN"                     , args: 1     , dialect: "*"     },
  { name: "ATAN"                     , args: [1, 2], dialect: "*"      , compile: compileAtan },
  { name: "ATAN2"                    , args: 2     , dialect: "*"     },
  { name: "CBRT"                     , args: 1     , dialect: "pgsql" },
  { name: "CEILING"                  , args: 1     , dialect: "*"     },
  { name: "COS"                      , args: 1     , dialect: "*"     },
  { name: "COT"                      , args: 1     , dialect: "*"     },
  { name: "DEGREES"                  , args: 1     , dialect: "*"     },
  { name: "EXP"                      , args: 1     , dialect: "*"     },
  { name: "FLOOR"                    , args: 1     , dialect: "*"     },
  { name: "LN"                       , args: 1     , dialect: "*"     },
  { name: "LOG"                      , args: [1, 2], dialect: "*"     },
  { name: "LOG10"                    , args: 1     , dialect: "*"      , compile: compileLog10 },
  { name: "LOG2"                     , args: 1     , dialect: "*"      , compile: compileLog2 },
  { name: "PI"                       , args: 0     , dialect: "*"     },
  { name: "POWER"                    , args: 2     , dialect: "*"     },
  { name: "RADIANS"                  , args: 1     , dialect: "*"     },
  { name: "RANDOM"                   , args: 0     , dialect: "*"      , compile: compileRandom },
  { name: "ROUND"                    , args: [1, 2], dialect: "*"     },
  { name: "SIGN"                     , args: 1     , dialect: "*"     },
  { name: "SIN"                      , args: 1     , dialect: "*"     },
  { name: "SQRT"                     , args: 1     , dialect: "*"     },
  { name: "TAN"                      , args: 1     , dialect: "*"     },
  { name: "TRUNC"                    , args: 1     , dialect: "*"      , compile: compileTrunc },
  { name: "WIDTH_BUCKET"             , args: 4     , dialect: "pgsql" }
], { category: "math", opFlags: OF.Function });

register([
  { name: "SETSEED"                  , args: 1     , dialect: "pgsql" }
], { category: "math", opFlags: OF.Function | OF.Void});

register([
  { name: "ASCII"                    , args: 1     , dialect: "*"     },
  { name: "BIT_LENGTH"               , args: 1     , dialect: "*"     },
  { name: "BTRIM"                    , args: [1, N], dialect: "*"      , compile: compileBTrim },
  { name: "CHAR"                     , args: [1, N], dialect: "mysql" },
  { name: "CHAR_LENGTH"              , args: 1     , dialect: "*"     },
  { name: "CHR"                      , args: 1     , dialect: "*"      , compile: compileChr },
  { name: "CONCAT"                   , args: [1, N], dialect: "*"     },
  { name: "CONCAT_WS"                , args: [2, N], dialect: "*"     },
  { name: "CONVERT"                  , args: 3     , dialect: "pgsql" },
  { name: "CONVERT_FROM"             , args: 2     , dialect: "pgsql" },
  { name: "CONVERT_TO"               , args: 2     , dialect: "pgsql" },
  { name: "FORMAT"                   , args: null  , dialect: "-"     },
  { name: "INITCAP"                  , args: 1     , dialect: "pgsql" },
  { name: "LEFT"                     , args: 2     , dialect: "*"     },
  { name: "LENGTH"                   , args: 1     , dialect: "*"     },
  { name: "LOWER"                    , args: 1     , dialect: "*"     },
  { name: "LPAD"                     , args: [2, 3], dialect: "*"     },
  { name: "LTRIM"                    , args: [1, N], dialect: "*"     },
  { name: "OCTET_LENGTH"             , args: 1     , dialect: "*"     },
  { name: "OVERLAY"                  , args: [3, 4], dialect: "pgsql"  , compile: compileOverlay },
  { name: "PG_CLIENT_ENCODING"       , args: 0     , dialect: "pgsql" },
  { name: "POSITION"                 , args: null  , dialect: "*"      , compile: compilePosition },
  { name: "REPEAT"                   , args: 2     , dialect: "*"     },
  { name: "REPLACE"                  , args: 3     , dialect: "*"     },
  { name: "REVERSE"                  , args: 1     , dialect: "*"     },
  { name: "RIGHT"                    , args: 2     , dialect: "*"     },
  { name: "RPAD"                     , args: [2, 3], dialect: "*"     },
  { name: "RTRIM"                    , args: [1, N], dialect: "*"     },
  { name: "SPLIT_PART"               , args: 3     , dialect: "pgsql" },
  { name: "STRCMP"                   , args: 2     , dialect: "mysql" },
  { name: "STRPOS"                   , args: 2     , dialect: "pgsql" },
  { name: "SUBSTR"                   , args: [2, 3], dialect: "*"     },
  { name: "SUBSTRING"                , args: [1, 3], dialect: "*"     , compile: compileSubString },
  { name: "TRANSLATE"                , args: 3     , dialect: "pgsql" },
  { name: "UPPER"                    , args: 1     , dialect: "*"     }
], { category: "string", opFlags: OF.Function });

register([
  { name: "AGE"                      , args: [1, 2], dialect: "*"     },
  { name: "CLOCK_TIMESTAMP"          , args: 0     , dialect: "*"     },
  { name: "CURRENT_DATE"             , args: 0     , dialect: "*"      , compile: compileCurrentDateTime },
  { name: "CURRENT_TIME"             , args: [0, 1], dialect: "*"      , compile: compileCurrentDateTime },
  { name: "CURRENT_TIMESTAMP"        , args: [0, 1], dialect: "*"      , compile: compileCurrentDateTime },
  { name: "DATE_PART"                , args: 2     , dialect: "*"     },
  { name: "DATE_TRUNC"               , args: 2     , dialect: "*"     },
  { name: "EXTRACT"                  , args: 2     , dialect: "*"      , compile: compileExtract },
  { name: "ISFINITE"                 , args: 1     , dialect: "*"     },
  { name: "JUSTIFY_DAYS"             , args: 1     , dialect: "*"     },
  { name: "JUSTIFY_HOURS"            , args: 1     , dialect: "*"     },
  { name: "JUSTIFY_INTERVAL"         , args: 1     , dialect: "*"     },
  { name: "LOCALTIME"                , args: [0, 1], dialect: "*"      , compile: compileCurrentDateTime },
  { name: "LOCALTIMESTAMP"           , args: [0, 1], dialect: "*"      , compile: compileCurrentDateTime },
  { name: "MAKE_DATE"                , args: 3     , dialect: "*"     },
  { name: "MAKE_INTERVAL"            , args: [0, 7], dialect: "*"     },
  { name: "MAKE_TIME"                , args: 3     , dialect: "*"     },
  { name: "MAKE_TIMESTAMP"           , args: 6     , dialect: "*"     },
  { name: "MAKE_TIMESTAMPTZ"         , args: [6, 7], dialect: "*"     },
  { name: "NOW"                      , args: 0     , dialect: "*"      , compile: compileNow },
  { name: "STATEMENT_TIMESTAMP"      , args: 0     , dialect: "*"     },
  { name: "TIMEOFDAY"                , args: 0     , dialect: "*"     },
  { name: "TO_TIMESTAMP"             , args: [1, 2], dialect: "*"     },
  { name: "TRANSACTION_TIMESTAMP"    , args: 0     , dialect: "*"     }
], { category: "datetime", opFlags: OF.Function });

register([
  { name: "TO_CHAR"                  , args: 2     , dialect: "pgsql" },
  { name: "TO_DATE"                  , args: 2     , dialect: "pgsql" },
  { name: "TO_NUMBER"                , args: 2     , dialect: "pgsql" },
  { name: "TO_TIMESTAMP"             , args: 2     , dialect: "pgsql" }
], { category: "datetime", opFlags: OF.Function });

register([
  { name: "DECODE"                   , args: null  , dialect: "*"     },
  { name: "ENCODE"                   , args: null  , dialect: "*"     },
  { name: "GET_BIT"                  , args: null  , dialect: "*"     },
  { name: "GET_BYTE"                 , args: null  , dialect: "*"     },
  { name: "QUOTE_IDENT"              , args: null  , dialect: "*"     },
  { name: "QUOTE_LITERAL"            , args: null  , dialect: "*"     },
  { name: "QUOTE_NULLABLE"           , args: null  , dialect: "*"     },
  { name: "REGEXP_MATCHES"           , args: null  , dialect: "*"     },
  { name: "REGEXP_REPLACE"           , args: null  , dialect: "*"     },
  { name: "REGEXP_SPLIT_TO_ARRAY"    , args: null  , dialect: "*"     },
  { name: "REGEXP_SPLIT_TO_TABLE"    , args: null  , dialect: "*"     },
  { name: "SET_BIT"                  , args: null  , dialect: "*"     },
  { name: "SET_BYTE"                 , args: null  , dialect: "*"     },
  { name: "TO_ASCII"                 , args: null  , dialect: "*"     },
  { name: "TO_HEX"                   , args: null  , dialect: "*"     }
], { category: "other", opFlags: OF.Function });

register([
  { name: "LAST_INSERT_ROWID"        , args: 0     , dialect: "sqlite"},
], { category: "other", opFlags: OF.Function });

register([
  { name: "MD5"                      , args: 1     , dialect: "*"     },
  { name: "SHA224"                   , args: 1     , dialect: "*"     },
  { name: "SHA256"                   , args: 1     , dialect: "*"     },
  { name: "SHA384"                   , args: 1     , dialect: "*"     },
  { name: "SHA512"                   , args: 1     , dialect: "*"     }
], { category: "hash", opFlags: OF.Function });

register([
  { name: "ISEMPTY"                  , args: 1     , dialect: "pgsql" },
  { name: "LOWER_INC"                , args: 1     , dialect: "pgsql" },
  { name: "LOWER_INF"                , args: 1     , dialect: "pgsql" },
  { name: "UPPER_INC"                , args: 1     , dialect: "pgsql" },
  { name: "UPPER_INF"                , args: 1     , dialect: "pgsql" },
  { name: "RANGE_MERGE"              , args: 2     , dialect: "pgsql" }
], { category: "range", opFlags: OF.Function });

register([
  { name: "ARRAY_APPEND"             , args: 2     , dialect: "pgsql" },
  { name: "ARRAY_CAT"                , args: 2     , dialect: "pgsql" },
  { name: "ARRAY_DIMS"               , args: 1     , dialect: "pgsql" },
  { name: "ARRAY_NDIMS"              , args: 1     , dialect: "pgsql" },
  { name: "ARRAY_FILL"               , args: [2, N], dialect: "pgsql" },
  { name: "ARRAY_LENGTH"             , args: 2     , dialect: "pgsql" },
  { name: "ARRAY_LOWER"              , args: 2     , dialect: "pgsql" },
  { name: "ARRAY_POSITION"           , args: [2, 3], dialect: "pgsql" },
  { name: "ARRAY_POSITIONS"          , args: 2     , dialect: "pgsql" },
  { name: "ARRAY_PREPEND"            , args: 2     , dialect: "pgsql" },
  { name: "ARRAY_REMOVE"             , args: 2     , dialect: "pgsql" },
  { name: "ARRAY_REPLACE"            , args: 3     , dialect: "pgsql" },
  { name: "ARRAY_TO_STRING"          , args: [2, 3], dialect: "pgsql" },
  { name: "ARRAY_UPPER"              , args: 2     , dialect: "pgsql" },
  { name: "CARDINALITY"              , args: 1     , dialect: "pgsql" },
  { name: "STRING_TO_ARRAY"          , args: [2, 3], dialect: "pgsql" },
  { name: "UNNEST"                   , args: [1, N], dialect: "pgsql" }
], { category: "array", opFlags: OF.Function });

register([
  { name: "ARRAY_TO_JSON"            , args: [1, 2], dialect: "pgsql" },
  { name: "JSON_ARRAY_ELEMENTS"      , args: 1     , dialect: "pgsql" },
  { name: "JSON_ARRAY_ELEMENTS_TEXT" , args: 1     , dialect: "pgsql" },
  { name: "JSON_ARRAY_LENGTH"        , args: 1     , dialect: "pgsql" },
  { name: "JSON_BUILD_ARRAY"         , args: [0, N], dialect: "pgsql" },
  { name: "JSON_BUILD_OBJECT"        , args: [0, N], dialect: "pgsql" },
  { name: "JSON_EACH"                , args: 1     , dialect: "pgsql" },
  { name: "JSON_EACH_TEXT"           , args: 1     , dialect: "pgsql" },
  { name: "JSON_EXTRACT_PATH"        , args: 2     , dialect: "pgsql" }, // #>
  { name: "JSON_EXTRACT_PATH_TEXT"   , args: 2     , dialect: "pgsql" }, // #>>
  { name: "JSON_OBJECT"              , args: [1, 2], dialect: "pgsql" },
  { name: "JSON_OBJECT_KEYS"         , args: 1     , dialect: "pgsql" },
  { name: "JSON_POPULATE_RECORD"     , args: 2     , dialect: "pgsql" },
  { name: "JSON_POPULATE_RECORDSET"  , args: 2     , dialect: "pgsql" },
  { name: "JSON_TYPEOF"              , args: 1     , dialect: "pgsql" },
  { name: "JSON_TO_RECORD"           , args: 1     , dialect: "pgsql" },
  { name: "JSON_STRIP_NULLS"         , args: 1     , dialect: "pgsql" },
  { name: "JSONB_ARRAY_ELEMENTS"     , args: 1     , dialect: "pgsql" },
  { name: "JSONB_ARRAY_ELEMENTS_TEXT", args: 1     , dialect: "pgsql" },
  { name: "JSONB_ARRAY_LENGTH"       , args: 1     , dialect: "pgsql" },
  { name: "JSONB_BUILD_ARRAY"        , args: [0, N], dialect: "pgsql" },
  { name: "JSONB_BUILD_OBJECT"       , args: [0, N], dialect: "pgsql" },
  { name: "JSONB_EACH"               , args: 1     , dialect: "pgsql" },
  { name: "JSONB_EACH_TEXT"          , args: 1     , dialect: "pgsql" },
  { name: "JSONB_EXTRACT_PATH"       , args: 2     , dialect: "pgsql" },
  { name: "JSONB_EXTRACT_PATH_TEXT"  , args: 2     , dialect: "pgsql" },
  { name: "JSONB_INSERT"             , args: [3, 4], dialect: "pgsql" },
  { name: "JSONB_OBJECT"             , args: [1, 2], dialect: "pgsql" },
  { name: "JSONB_OBJECT_KEYS"        , args: 1     , dialect: "pgsql" },
  { name: "JSONB_POPULATE_RECORD"    , args: 2     , dialect: "pgsql" },
  { name: "JSONB_POPULATE_RECORDSET" , args: 2     , dialect: "pgsql" },
  { name: "JSONB_PRETTY"             , args: 1     , dialect: "pgsql" },
  { name: "JSONB_TYPEOF"             , args: 1     , dialect: "pgsql" },
  { name: "JSONB_TO_RECORD"          , args: 1     , dialect: "pgsql" },
  { name: "JSONB_SET"                , args: [3, 4], dialect: "pgsql" },
  { name: "JSONB_STRIP_NULLS"        , args: 1     , dialect: "pgsql" },
  { name: "ROW_TO_JSON"              , args: [1, 2], dialect: "pgsql" },
  { name: "TO_JSON"                  , args: 1     , dialect: "pgsql" },
  { name: "TO_JSONB"                 , args: 1     , dialect: "pgsql" }
], { category: "json", opFlags: OF.Function });

register([
  { name: "STRING_AGG"               , args: 2     , dialect: "pgsql" }
], { category: "string", opFlags: OF.Function | OF.Aggregate });

register([
  { name: "ARRAY_AGG"                , args: 1     , dialect: "pgsql" }
], { category: "array", opFlags: OF.Function | OF.Aggregate });

register([
  { name: "AVG"                      , args: 1     , dialect: "*"     },
  { name: "BIT_AND"                  , args: 1     , dialect: "*"     },
  { name: "BIT_OR"                   , args: 1     , dialect: "*"     },
  { name: "BIT_XOR"                  , args: 1     , dialect: "mysql" },
  { name: "BOOL_AND"                 , args: 1     , dialect: "pgsql" },
  { name: "BOOL_OR"                  , args: 1     , dialect: "pgsql" },
  { name: "COUNT"                    , args: 1     , dialect: "*"     },
  { name: "MAX"                      , args: 1     , dialect: "*"     },
  { name: "MIN"                      , args: 1     , dialect: "*"     },
  { name: "SUM"                      , args: 1     , dialect: "*"     }
], { category: "general", opFlags: OF.Function | OF.Aggregate });

register([
  { name: "CORR"                     , args: 2     , dialect: "pgsql" },
  { name: "COVAR_POP"                , args: 2     , dialect: "pgsql" },
  { name: "COVAR_SAMP"               , args: 2     , dialect: "pgsql" },
  { name: "REGR_AVGX"                , args: 2     , dialect: "pgsql" },
  { name: "REGR_AVGY"                , args: 2     , dialect: "pgsql" },
  { name: "REGR_COUNT"               , args: 2     , dialect: "pgsql" },
  { name: "REGR_INTERCEPT"           , args: 2     , dialect: "pgsql" },
  { name: "REGR_R2"                  , args: 2     , dialect: "pgsql" },
  { name: "REGR_SLOPE"               , args: 2     , dialect: "pgsql" },
  { name: "REGR_SXX"                 , args: 2     , dialect: "pgsql" },
  { name: "REGR_SXY"                 , args: 2     , dialect: "pgsql" },
  { name: "REGR_SYY"                 , args: 2     , dialect: "pgsql" },
  { name: "STDDEV_POP"               , args: 1     , dialect: "pgsql" },
  { name: "STDDEV_SAMP"              , args: 1     , dialect: "pgsql" },
  { name: "VAR_POP"                  , args: 1     , dialect: "pgsql" },
  { name: "VAR_SAMP"                 , args: 1     , dialect: "pgsql" }
], { category: "statistics", opFlags: OF.Function | OF.Aggregate });

register([
  { name: "CUME_DIST"                , args: [1, N], dialect: "pgsql" },
  { name: "DENSE_RANK"               , args: [1, N], dialect: "pgsql" },
  { name: "PERCENT_RANK"             , args: [1, N], dialect: "pgsql" },
  { name: "RANK"                     , args: [1, N], dialect: "pgsql" }
], { category: "hypothetical-set", opFlags: OF.Function | OF.Aggregate });

register([
  { name: "JSON_AGG"                 , args: 1     , dialect: "pgsql" },
  { name: "JSON_OBJECT_AGG"          , args: 2     , dialect: "pgsql" },
  { name: "JSONB_AGG"                , args: 2     , dialect: "pgsql" },
  { name: "JSONB_OBJECT_AGG"         , args: 2     , dialect: "pgsql" }
], { category: "json", opFlags: OF.Function | OF.Aggregate });

register([
  { name: "XMLAGG"                   , args: 1     , dialect: "pgsql" }
], { category: "xml", opFlags: OF.Function | OF.Aggregate });

OpInfo.addAlias("TRIM", "BTRIM");
OpInfo.addAlias("POW", "POWER");
OpInfo.addAlias("CEIL", "CEILING");
OpInfo.addAlias("EVERY", "BOOL_AND");
OpInfo.addAlias("STDDEV", "STDDEV_SAMP");
OpInfo.addAlias("VARIANCE", "VAR_SAMP");

OpInfo.addAlias("!=", "<>");
OpInfo.addNegation("=", "<>");
OpInfo.addNegation(">", "<=");
OpInfo.addNegation("<", ">=");
OpInfo.addNegation("~", "!~");
OpInfo.addNegation("~*", "!~*");

// Add all known functions to `xql` namespace.
OpInfo.forEach(function(alias, info) {
  if (info.opFlags & (OF.Unary | OF.Binary | OF.Function) && reUpperOperatorName.test(info.name)) {
    const funcName = alias.replace(/ /g, "_");
    if (!xql[funcName]) {
      if (info.opFlags & OF.Unary)
        xql[funcName] = Unary.makeWrap(info.name, info.nodeFlags, info.ctor);
      else if (info.opFlags & OF.Binary)
        xql[funcName] = Binary.makeWrap(info.name, info.nodeFlags, info.ctor);
      else
        xql[funcName] = Func.makeWrap(info.name, info.nodeFlags, info.ctor);
    }
  }
});

})();

// ============================================================================
// [xql.SQL]
// ============================================================================

xql.ADD = Binary.makeWrap("+", OpInfo.get("+").nodeFlags);
xql.SUB = Binary.makeWrap("-", OpInfo.get("-").nodeFlags);
xql.MUL = Binary.makeWrap("*", OpInfo.get("*").nodeFlags);
xql.DIV = Binary.makeWrap("/", OpInfo.get("/").nodeFlags);
xql.MOD = Binary.makeWrap("%", OpInfo.get("%").nodeFlags);

xql.EQ = Binary.makeWrap("=" , OpInfo.get("=" ).nodeFlags);
xql.NE = Binary.makeWrap("<>", OpInfo.get("<>").nodeFlags);
xql.LT = Binary.makeWrap("<" , OpInfo.get("<" ).nodeFlags);
xql.LE = Binary.makeWrap("<=", OpInfo.get("<=").nodeFlags);
xql.GT = Binary.makeWrap(">" , OpInfo.get(">" ).nodeFlags);
xql.GE = Binary.makeWrap(">=", OpInfo.get(">=").nodeFlags);

/**
 * Constructs a logical AND expression.
 *
 * @param {...*} args Arguments passed as an array or as `...args`.
 *   Arguments must be SQL conditions that form the AND expression.
 * @return {Logical}
 *
 * @alias xql.AND
 */
xql.AND = NodeArray.makeWrap("AND", OpInfo.get("AND").nodeFlags, Logical);

/**
 * Constructs a logical OR expression.
 *
 * @param {...*} args Arguments passed as an array or as `...args`.
 *   Arguments must be SQL conditions that form the OR expression.
 * @return {Logical}
 *
 * @alias xql.OR
 */
xql.OR = NodeArray.makeWrap("OR", OpInfo.get("OR").nodeFlags, Logical);

/**
 *
 * Constructs either unary or binary operator.
 *
 * Examples:
 *   OP(op, a) - Unary operator.
 *   OP(a, op, b) - Binary operator.
 */
function OP() {
  if (arguments.length === 2) {
    const op = arguments[0];
    const a = arguments[1];
    return UNARY_OP(op, a);
  }

  if (arguments.length === 3) {
    const a  = arguments[0];
    const op = arguments[1];
    const b  = arguments[2];
    return BINARY_OP(a, op, b);
  }

  throwCompileError("OP() - Illegal number or parameters '" + len + "' (2 or 3 allowed)");
}
xql.OP = OP;

}).apply(this, typeof module === "object" && module && module.exports
  ? [module, "exports"] : [this, "xql"]);