sql-love 1.0.2 → 1.0.4

package/src/Parser/Parser.spec.ts

@@ -1,226 +0,0 @@
-import SelectBuilder from '../SelectBuilder/SelectBuilder';
-
-const trim = s => s.replace(/\s+/g, ' ').trim();
-
-describe('column handler', () => {
-  it('should recognize asterisk', () => {
-    const query = new SelectBuilder('SELECT * FROM mytable');
-    expect(query._columns).toEqual(['*']);
-  });
-});
-describe('comment handler', () => {
-  it('should strip single-line comments -- dashes', () => {
-    const query = new SelectBuilder(
-      `
-  			SELECT
-  			-- stuff
-  			a,
-  				-- more stuff
-  			b -- and even more stuff
-  			FROM mytable
-  		`
-    );
-    expect(trim(query.compile().sql)).toBe('SELECT a, b FROM mytable');
-  });
-  it('should strip single-line comments #hash', () => {
-    const query = new SelectBuilder(
-      `
-  			SELECT
-  			#stuff
-  			a,
-  				# more stuff
-  			b #and even more stuff
-  			FROM mytable
-  		`
-    );
-    expect(trim(query.compile().sql)).toBe('SELECT a, b FROM mytable');
-  });
-  it('should strip multi-line comments', () => {
-    const query = new SelectBuilder(
-      `
-  			SELECT
-  			/*
-  				stuff
-  			*/
-  			a,
-  				/* more stuff */ b
-  			FROM mytable
-  		`
-    );
-    expect(trim(query.compile().sql)).toBe('SELECT a, b FROM mytable');
-  });
-});
-describe('subquery handler', () => {
-  it('should handle column subqueries', () => {
-    const normalized =
-      'SELECT a, (SELECT * FROM tbl2) AS b FROM mytable WHERE mycol = 1';
-    const query = new SelectBuilder(normalized);
-    expect(trim(query.compile().sql)).toBe(normalized);
-  });
-  it('should handle column subqueries with SELECT EXISTS', () => {
-    const normalized =
-      'SELECT a, (SELECT EXISTS (SELECT * FROM tbl2)) AS b FROM mytable WHERE mycol = 1';
-    const query = new SelectBuilder(normalized);
-    expect(trim(query.compile().sql)).toBe(normalized);
-  });
-  it('should handle IF() column expressions', () => {
-    const normalized =
-      'SELECT a, IF(b > 0) AS is_gt_0, IF(b > 100) AS is_gt_100 FROM mytable WHERE mycol = 1';
-    const query = new SelectBuilder(normalized);
-    expect(trim(query.compile().sql)).toBe(normalized);
-  });
-  it('should handle IN() expressions in WHERE', () => {
-    const normalized =
-      'SELECT * FROM mytable WHERE mycol IN (SELECT id FROM othertable)';
-    const query = new SelectBuilder(normalized);
-    expect(trim(query.compile().sql)).toBe(normalized);
-  });
-  it('should handle IN() expressions in JOINs', () => {
-    const normalized =
-      'SELECT * FROM a INNER JOIN b ON b.id = a.b_id AND b.status IN (SELECT id FROM statuses) WHERE a.id > 10';
-    const query = new SelectBuilder(normalized);
-    expect(trim(query.compile().sql)).toBe(normalized);
-  });
-});
-describe('table handler', () => {
-  it('should parse single table', () => {
-    const query = new SelectBuilder('SELECT * FROM a');
-    expect(query._tables).toEqual(['a']);
-  });
-  it('should parse comma-separated tables', () => {
-    const query = new SelectBuilder('SELECT * FROM a, b');
-    expect(query._tables).toEqual(['a', 'b']);
-  });
-});
-describe('column handler', () => {
-  it('should parse single column', () => {
-    const query = new SelectBuilder('SELECT a FROM b');
-    expect(query._columns).toEqual(['a']);
-  });
-  it('should parse comma-separated columns', () => {
-    const query = new SelectBuilder('SELECT a, b FROM c');
-    expect(query._columns).toEqual(['a', 'b']);
-  });
-  it('should handle expressions with one comma', () => {
-    const query = new SelectBuilder("SELECT a, CONCAT('b',b) FROM c");
-    expect(query._columns).toEqual(['a', "CONCAT('b',b)"]);
-  });
-  it('should handle expressions with 2 commas', () => {
-    const query = new SelectBuilder(
-      "SELECT a, CONCAT(fname, ' ', lname) FROM users"
-    );
-    expect(query._columns).toEqual(['a', "CONCAT(fname, ' ', lname)"]);
-  });
-});
-describe('option handler', () => {
-  it('should save SQL_CALC_FOUND_ROWS as an option', () => {
-    const query = new SelectBuilder('SELECT SQL_CALC_FOUND_ROWS * FROM a');
-    expect(query._columns).toEqual(['*']);
-    expect(query._options).toEqual(['SQL_CALC_FOUND_ROWS']);
-  });
-});
-describe('JOIN handler', () => {
-  const joins = [
-    'JOIN',
-    'INNER JOIN',
-    'LEFT JOIN',
-    'LEFT OUTER JOIN',
-    'OUTER JOIN',
-    'RIGHT JOIN',
-    'RIGHT OUTER JOIN',
-    'CROSS JOIN',
-    'FULL JOIN',
-    'FULL OUTER JOIN',
-  ];
-  joins.forEach(join => {
-    it(`should handle ${join}`, () => {
-      const sql = `SELECT * FROM a ${join} b ON b.id = a.b_id`;
-      const query = new SelectBuilder(sql);
-      expect(trim(query.compile().sql)).toBe(sql);
-    });
-  });
-});
-describe('conditions handler', () => {
-  it('should parse WHERE 1 = 1', () => {
-    const query = new SelectBuilder('SELECT * FROM mytable WHERE 1 = 1');
-    expect(query._wheres).toEqual(['1 = 1']);
-  });
-  it("should parse WHERE '1'", () => {
-    const query = new SelectBuilder("SELECT * FROM mytable WHERE '1'");
-    expect(query._wheres).toEqual(["'1'"]);
-  });
-  it('should parse WHERE true', () => {
-    const query = new SelectBuilder('SELECT * FROM mytable WHERE true');
-    expect(query._wheres).toEqual(['true']);
-  });
-  it('should parse single WHERE', () => {
-    const query = new SelectBuilder('SELECT * FROM mytable WHERE mycol = 1');
-    expect(query._wheres).toEqual(['mycol = 1']);
-  });
-  it('should parse two WHERE clauses joined by AND', () => {
-    const query = new SelectBuilder(
-      'SELECT * FROM mytable WHERE mycol = 1 AND scheduled < NOW()'
-    );
-    expect(query._wheres).toEqual(['mycol = 1', 'scheduled < NOW()']);
-  });
-  it('should parse two WHERE clauses joined by OR', () => {
-    const query = new SelectBuilder(
-      'SELECT * FROM mytable WHERE mycol = 1 OR scheduled < NOW()'
-    );
-    expect(query._wheres).toEqual(['(mycol = 1 OR scheduled < NOW())']);
-  });
-  it('should parse OR then AND', () => {
-    const query = new SelectBuilder(
-      'SELECT * FROM mytable WHERE a = 1 OR b = 2 AND c = 3'
-    );
-    expect(query._wheres).toEqual(['(a = 1 OR b = 2)', 'c = 3']);
-  });
-  it('should parse OR then AND with parens', () => {
-    const query = new SelectBuilder(
-      'SELECT * FROM mytable WHERE (a = 1 OR b = 2) AND c = 3'
-    );
-    expect(query._wheres).toEqual(['(a = 1 OR b = 2)', 'c = 3']);
-  });
-  it('should parse AND then OR', () => {
-    const query = new SelectBuilder(
-      'SELECT * FROM mytable WHERE a = 1 AND b = 2 OR c = 3'
-    );
-    expect(query._wheres).toEqual(['a = 1', '(b = 2 OR c = 3)']);
-  });
-});
-it('should parse GROUP BY and HAVING', () => {
-  const query = new SelectBuilder(
-    'SELECT name, COUNT(*) FROM mytable GROUP BY name HAVING COUNT(*) > 1'
-  );
-  expect(query._groupBys).toEqual(['name']);
-  expect(query._havings).toEqual(['COUNT(*) > 1']);
-});
-it('should parse ORDER BY', () => {
-  const query = new SelectBuilder('SELECT * FROM users ORDER BY id DESC');
-  expect(query._orderBys).toEqual(['id DESC']);
-});
-describe('pagination', () => {
-  it('should parse LIMIT with number', () => {
-    const query = new SelectBuilder('SELECT * FROM mytable LIMIT 1');
-    expect(query._limit).toBe(1);
-  });
-  it('should parse OFFSET with number', () => {
-    const query = new SelectBuilder('SELECT * FROM mytable LIMIT 5 OFFSET 10');
-    expect(query._offset).toBe(10);
-  });
-  it('should parse OFFSET, LIMIT with numbers', () => {
-    const query = new SelectBuilder('SELECT * FROM mytable LIMIT 10, 5');
-    expect(query._limit).toBe(5);
-    expect(query._offset).toBe(10);
-  });
-  it('should parse OFFSET # ROWS', () => {
-    const query = new SelectBuilder('SELECT * FROM mytable OFFSET 10 ROWS');
-    expect(query._offset).toBe(10);
-  });
-  it('should parse FETCH NEXT # ROWS ONLY', () => {
-    const query = new SelectBuilder(
-      'SELECT * FROM mytable FETCH NEXT 10 ROWS ONLY'
-    );
-    expect(query._limit).toBe(10);
-  });
-});

package/src/Parser/Parser.ts

@@ -1,325 +0,0 @@
-import type Select from '../SelectBuilder/SelectBuilder';
-
-/**
- * Parse SQL and populate onto a Select query object
- */
-export default class Parser {
-  query: Select;
-
-  /**
-   * Create a new instance
-   * @param query  A Select object on which to build parsed conditions
-   */
-  constructor(query: Select) {
-    this.query = query;
-  }
-
-  /**
-   * Strip single-line and multi-line comment blocks
-   * @param sql  The SQL string
-   * @return  The SQL string without comments
-   * @private
-   */
-  _stripComments(sql: string) {
-    // multiline comments
-    sql = sql.replace(/\/\*[\s\S]*?\*\//g, '');
-    // single line comments -- dashes
-    sql = sql.replace(/--([\r\n]|\s+[^\r\n]+[\r\n])/g, '');
-    // single line comments #hashes
-    sql = sql.replace(/#[^\r\n]+[\r\n]/g, '');
-    return sql;
-  }
-
-  /**
-   * Before splitting into SQL clauses, extract some regex-able subQueries
-   * @param sql  The unparsed sql string
-   * @return  An array with new sql and subQueries
-   * @private
-   */
-  _extractSubQueries(sql: string) {
-    const subQueries = {};
-    let i = 0;
-    const extractor = $0 => {
-      const placeholder = `~~SUBQUERY_${i++}~~`;
-      subQueries[placeholder] = $0;
-      return placeholder;
-    };
-    // subselect in FROM clause
-    sql = sql.replace(/\(\s*SELECT\s+.+\)\s+AS\s+[^\s,]+/, extractor);
-    // IF() in FROM clause
-    sql = sql.replace(/\bIF\s*\(.+\)\s+AS\s+[^\s,]+/, extractor);
-    // IN (SELECT *) in JOINs, WHERE or HAVING
-    sql = sql.replace(/\bIN\s*\(\s*SELECT\s.+?\)/, extractor);
-    return { sql, subQueries };
-  }
-
-  /**
-   * Inject column subQueries back into this object
-   * @param subQueries  The lookup of extracted subQueries
-   * @private
-   */
-  _injectSubQueries(subQueries: Record<string, string>) {
-    const replacer = $0 => {
-      return subQueries[$0] || $0;
-    };
-    const mapper = clause => {
-      return clause.replace(/~~SUBQUERY_\d+~~/g, replacer);
-    };
-    this.query._columns = this.query._columns.map(replacer);
-    this.query._joins = this.query._joins.map(mapper);
-    this.query._wheres = this.query._wheres.map(mapper);
-    this.query._havings = this.query._havings.map(mapper);
-  }
-
-  /**
-   * Split SQL into clauses (used by parse())
-   * @param sql  The SQL to split
-   * @return
-   * @private
-   */
-  _split(sql: string) {
-    const splitter =
-      /(?:^|\s)(SELECT|FROM|(?:INNER|LEFT\s+OUTER|RIGHT\s+OUTER|LEFT|RIGHT|CROSS|FULL|FULL\s+OUTER)\s+JOIN|WHERE|GROUP\s+BY|HAVING|ORDER\s+BY|LIMIT|OFFSET|FETCH\s+NEXT)\b/i;
-    return sql.split(splitter);
-  }
-
-  /**
-   * Get a QuickSelect object representing the given SQL SELECT statement
-   * @param  rawSql  The raw SQL for the SELECT statement
-   * @return True if the SQL was parsed successfully
-   */
-  parse(rawSql: string) {
-    const stripped = this._stripComments(rawSql);
-    const { sql, subQueries } = this._extractSubQueries(stripped);
-    const expressions = this._split(sql);
-    let i = 1;
-    while (i < expressions.length) {
-      const rawKeyword = expressions[i++].trim();
-      const keyword = rawKeyword.toUpperCase().replace(/\s+/g, '_');
-      const clause = expressions[i++].trim();
-      const handler = `_handle${keyword}`;
-      this[handler](clause);
-    }
-    this._injectSubQueries(subQueries);
-    return true;
-  }
-
-  /**
-   * Handle SQL_CALC_FOUND_ROWS and column names
-   * @param clause  The clause after the SELECT
-   * @private
-   */
-  _handleSELECT(clause: string) {
-    let columns = clause.split(/s*,s*/);
-    // now handle parenthesis expressions that contain commas
-    let buffer = '';
-    columns.forEach((column, i) => {
-      if (i === 0) {
-        const optionRegex = /^(SQL_CALC_FOUND_ROWS)\s+/i;
-        const match = column.match(optionRegex);
-        if (match) {
-          this.query.option(match[1]);
-          column = column.replace(optionRegex, '');
-        }
-      }
-      if (buffer.length) {
-        // we are in the middle of an expression containing parenthesis
-        if (column.indexOf(')') > 0) {
-          // we have an end parenthesis
-          buffer += column;
-          this.query.column(buffer.trim());
-          buffer = '';
-        } else {
-          buffer += column + ',';
-        }
-      } else if (column.match(/\([^)]+$/)) {
-        buffer = column + ',';
-      } else {
-        this.query.column(column.trim());
-      }
-    });
-  }
-
-  /**
-   * Handle table names
-   * @param clause  The clause after the FROM
-   * @private
-   */
-  _handleFROM(clause: string) {
-    const tables = clause.split(/\s*,\s*/);
-    tables.forEach(table => this.query.table(table));
-  }
-
-  /**
-   * Handle INNER JOIN statements
-   * @param clause  The clause after the INNER JOIN
-   * @private
-   */
-  _handleINNER_JOIN(clause: string) {
-    this.query.innerJoin(clause);
-  }
-
-  /**
-   * Handle LEFT JOIN statements
-   * @param clause  The clause after the LEFT JOIN
-   * @private
-   */
-  _handleLEFT_JOIN(clause: string) {
-    this.query.leftJoin(clause);
-  }
-
-  /**
-   * Handle LEFT OUTER JOIN statements
-   * @param clause  The clause after the LEFT OUTER JOIN
-   * @private
-   */
-  _handleLEFT_OUTER_JOIN(clause: string) {
-    this.query.leftOuterJoin(clause);
-  }
-
-  /**
-   * Handle RIGHT JOIN statements
-   * @param clause  The clause after the RIGHT JOIN
-   * @private
-   */
-  _handleRIGHT_JOIN(clause: string) {
-    this.query.rightJoin(clause);
-  }
-
-  /**
-   * Handle RIGHT OUTER JOIN statements
-   * @param clause  The clause after the RIGHT OUTER JOIN
-   * @private
-   */
-  _handleRIGHT_OUTER_JOIN(clause: string) {
-    this.query.rightOuterJoin(clause);
-  }
-
-  /**
-   * Handle CROSS JOIN statements
-   * @param clause  The clause after the CROSS JOIN
-   * @private
-   */
-  _handleCROSS_JOIN(clause: string) {
-    this.query.crossJoin(clause);
-  }
-
-  /**
-   * Handle FULL JOIN statements
-   * @param clause  The clause after the FULL JOIN
-   * @private
-   */
-  _handleFULL_JOIN(clause: string) {
-    this.query.fullJoin(clause);
-  }
-
-  /**
-   * Handle FULL OUTER JOIN statements
-   * @param clause  The clause after the FULL OUTER JOIN
-   * @private
-   */
-  _handleFULL_OUTER_JOIN(clause: string) {
-    this.query.fullOuterJoin(clause);
-  }
-
-  /**
-   * Handle WHERE conditions
-   * @param clause  All the conditions after WHERE
-   * @private
-   */
-  _handleWHERE(clause: string) {
-    if (/^(1|'1'|true)$/i.test(clause)) {
-      this.query._wheres.push(clause);
-    } else {
-      this._handleConditions('where', clause);
-    }
-  }
-
-  /**
-   * Handle HAVING statements
-   * @param clause  All the conditions after HAVING
-   * @private
-   */
-  _handleHAVING(clause: string) {
-    this._handleConditions('having', clause);
-  }
-
-  /**
-   * Build a conditions list
-   * @param type  Either where or having
-   * @param clause  The expressions following the type keyword
-   * @private
-   */
-  _handleConditions(type: 'where' | 'having', clause: string) {
-    const andGroups = clause.split(/\bAND\b/i);
-    andGroups.forEach(andGroup => {
-      const orPieces = andGroup.split(/\bOR\b/i).map(str => str.trim());
-      if (orPieces.length === 1) {
-        // no OR operators
-        const fn = type; // either where or having
-        this.query[fn](orPieces[0]);
-      } else {
-        // some OR operators
-        // either orWhere or orHaving
-        const orFn = type === 'where' ? 'orWhere' : 'orHaving';
-        this.query[orFn](orPieces.map(p => [p]));
-      }
-    });
-  }
-
-  /**
-   * Handle GROUP BY statements
-   * @param clause  The clauses after the GROUP BY
-   * @private
-   */
-  _handleGROUP_BY(clause: string) {
-    const columns = clause.split(/\s*,\s*/);
-    columns.forEach(column => this.query.groupBy(column));
-  }
-
-  /**
-   * Handle ORDER BY statements
-   * @param clause  The clause after the ORDER BY
-   * @private
-   */
-  _handleORDER_BY(clause: string) {
-    const columns = clause.split(/\s*,\s*/);
-    columns.forEach(column => this.query.orderBy(column));
-  }
-
-  /**
-   * Handle LIMIT statements including "LIMIT #" and "LIMIT #, #"
-   * @param clause  The clause after the LIMIT
-   * @private
-   */
-  _handleLIMIT(clause: string) {
-    const offsetLimit = clause.match(/^(\d+|\?|:\w+)\s*,\s*(\d+|\?|:\w+)$/);
-    if (offsetLimit) {
-      this.query.offset(offsetLimit[1]);
-      this.query.limit(offsetLimit[2]);
-    } else {
-      clause = clause.replace(/ ROWS$/i, '');
-      this.query.limit(clause);
-    }
-  }
-
-  /**
-   * Handle OFFSET statements
-   * @param clause  The number after the OFFSET
-   * @private
-   */
-  _handleOFFSET(clause: string) {
-    clause = clause.replace(/^(\d+) ROWS$/i, '$1');
-    this.query.offset(clause);
-  }
-
-  /**
-   * Handle OFFSET statements
-   * @param clause  The number after the OFFSET
-   * @private
-   */
-  _handleFETCH_NEXT(clause: string) {
-    clause = clause.replace(/^(\d+) ROWS ONLY$/i, '$1');
-    this.query.limit(clause);
-  }
-}