@sap/cds 8.9.4 → 9.0.2

package/libx/_runtime/db/sql-builder/ExpressionBuilder.js

@@ -1,345 +0,0 @@
-const BaseBuilder = require('./BaseBuilder')
-const { flattenStructuredWhereHaving } = require('../../common/utils/structured')
-
-function _valButNoBuffer(arg) {
-  return arg && arg.val && typeof arg.val === 'object' && !(arg.val instanceof Buffer)
-}
-
-/**
- * ExpressionBuilder is used to take a part of a CQN object as an input and to build an object representing an expression
- * with SQL string and values to be used with a prepared statement.
- * The outer property 'xpr' can be omitted.
- *
- * @example <caption>Example of xpr part of CQN </caption>
- * {
- *  xpr: [{ref: ['x']}, '<', {val: 9}]
- * }
- *
- * Each operand of the xpr can be a nested xpr.
- */
-class ExpressionBuilder extends BaseBuilder {
-  /**
-   * The constructor of the ExpressionBuilder.
-   * If the options parameter is not specified, " are used as delimiter and ? as placeholders.
-   *
-   * @param {object} obj - Part of the CQN object that represents an expression
-   * @param {object} [options] - The configuration object.
-   * @param {string} [options.delimiter] - The delimiter string.
-   * @param {string} [options.placeholder] - The placeholder for prepared statement.
-   * @param {string} [options.objectKey] - The object key for the expression. It can be either "xpr" or empty string.
-   * @param {object} csn - The csn object
-   * Default is an empty string.
-   */
-  constructor(obj, options, csn) {
-    super(obj, options, csn)
-    this._options = Object.assign({ objectKey: '' }, this._options)
-  }
-
-  get SelectBuilder() {
-    const SelectBuilder = require('./SelectBuilder')
-    Object.defineProperty(this, 'SelectBuilder', { value: SelectBuilder })
-    return SelectBuilder
-  }
-
-  get ReferenceBuilder() {
-    const ReferenceBuilder = require('./ReferenceBuilder')
-    Object.defineProperty(this, 'ReferenceBuilder', { value: ReferenceBuilder })
-    return ReferenceBuilder
-  }
-
-  get FunctionBuilder() {
-    const FunctionBuilder = require('./FunctionBuilder')
-    Object.defineProperty(this, 'FunctionBuilder', { value: FunctionBuilder })
-    return FunctionBuilder
-  }
-
-  /**
-   * Builds an Object based on the properties of the input object in the constructor.
-   *
-   * @example <caption>Example output</caption>
-   * {
-   *    sql: '"X" < ?',
-   *    values: [1]
-   * }
-   *
-   * @throws Error if the input object is invalid
-   * @returns {{sql: string, values: Array}} Object with two properties.
-   * SQL string for prepared statement and array of values to replace the placeholders.
-   */
-  build() {
-    this._outputObj = {
-      sql: [],
-      values: []
-    }
-
-    this._expressionObjectsToSQL(
-      this._options.objectKey && this._obj[this._options.objectKey] ? this._obj[this._options.objectKey] : this._obj
-    )
-
-    this._outputObj.sql = this._outputObj.sql.join(' ')
-    return this._outputObj
-  }
-
-  _isStructured(op1, comp, op2) {
-    if (op1.ref && comp === '=' && _valButNoBuffer(op2)) return true
-    // also check reverse
-    if (_valButNoBuffer(op1) && comp === '=' && op2.ref) return true
-  }
-
-  _hasValToValComparision(op1, comp, op2) {
-    const _operations = ['=', '!=']
-    return typeof op1.val === 'number' && _operations.includes(comp) && typeof op2.val === 'number'
-  }
-
-  _expressionObjectsToSQL(objects) {
-    const length = objects.length
-    let i = 0
-
-    while (i < length) {
-      // Some keywords need to be process as a block, while others can be treated one at a time
-      const reserved = this._reseverdKeyWords(objects, i)
-      if (reserved) {
-        i = i + reserved
-      } else {
-        if (this._isStructured(objects[i], objects[i + 1], objects[i + 2])) {
-          // this is a special case where we detect structured and convert it to flat expression
-          const entity = this._csn && this._csn.definitions[this._options.entityName]
-          const flattenedStructExpression = flattenStructuredWhereHaving(
-            [objects[i], '=', objects[i + 2]],
-            entity,
-            this._csn
-          )
-          this._expressionObjectsToSQL(flattenedStructExpression)
-          i += 3
-          continue
-        } else if (this._hasValToValComparision(objects[i], objects[i + 1], objects[i + 2])) {
-          // Avoid utilizing placeholders to represent numerical values being (not) equal to other numbers due to an issue related to HDB.
-          const _outputObj = this._outputObj
-          _outputObj.sql.push(objects[i].val)
-          _outputObj.sql.push(objects[i + 1])
-          _outputObj.sql.push(objects[i + 2].val)
-          i += 3
-          continue
-        }
-
-        this._expressionElementToSQL(objects[i])
-        i++
-      }
-    }
-  }
-
-  /**
-   * Some values and operators need to be treated in a non standard way.
-   * Those are:
-   * (NOT) NULL
-   * (NOT) IN
-   *
-   * @param {Array} objects
-   * @param {number} i
-   * @returns {number}
-   * @private
-   */
-  _reseverdKeyWords(objects, i) {
-    const NOT_EQUAL = { '!=': 1, '<>': 1 }
-    if (objects[i] === 'not' && objects[i + 1].func) {
-      objects[i + 1].func = `not ${objects[i + 1].func}`
-      return 1
-    }
-
-    if ((objects[i + 1] === '=' || objects[i + 1] in NOT_EQUAL) && objects[i + 2] && objects[i + 2].val === null) {
-      this._addNullOrNotNull(objects[i], objects[i + 1])
-      return 3
-    }
-
-    if (objects[i].val === null && (objects[i + 1] === '=' || objects[i + 1] in NOT_EQUAL) && objects[i + 2]) {
-      this._addNullOrNotNull(objects[i + 2], objects[i + 1])
-      return 3
-    }
-
-    if (/^(not )?in+/i.test(objects[i + 1])) {
-      this._addInOrNotIn(objects[i], objects[i + 1].toUpperCase(), objects[i + 2])
-      return 3
-    }
-
-    return 0
-  }
-
-  /**
-   * In case the value is null, SQL with reserved keywords and without a placeholder is required.
-   *
-   * @param reference
-   * @param operator
-   * @returns {boolean}
-   * @private
-   */
-  _addNullOrNotNull(reference, operator) {
-    if (reference.ref) {
-      this._addToOutputObj(new this.ReferenceBuilder(reference, this._options, this._csn).build(), false)
-    } else {
-      this._outputObj.sql.push(this._options.placeholder)
-      // convert to String, otherwise hdb driver complains because of type conversion issues
-      this._outputObj.values.push(reference.val === null ? reference.val : reference.val + '')
-    }
-
-    this._outputObj.sql.push('IS', `${operator !== '=' ? 'NOT ' : ''}NULL`)
-
-    return true
-  }
-
-  /**
-   * (NOT) IN can have an Array or sub select instance as value.
-   *
-   * @param reference
-   * @param operator
-   * @param values
-   * @returns {boolean}
-   * @private
-   */
-  _addInOrNotIn(reference, operator, values) {
-    if (Array.isArray(values.list)) {
-      this._expressionElementToSQL(reference)
-      this._outputObj.sql.push(operator)
-      this._addListToOutputObj(values.list)
-      return true
-    }
-
-    this._addSubQueryForInQuery(reference, operator, values)
-    return true
-  }
-
-  _addArrayForInQuery(reference, operator, values) {
-    this._addToOutputObj(new this.ReferenceBuilder(reference, this._options, this._csn).build(), false)
-
-    const placeholders = []
-
-    for (let i = 0, length = values.length; i < length; i++) {
-      placeholders.push(this._options.placeholder)
-    }
-
-    this._outputObj.sql.push(operator, '(', `${placeholders.join(', ')}`, ')')
-
-    this._outputObj.values = this._outputObj.values.concat(values)
-  }
-
-  _addSubQueryForInQuery(reference, operator, subQuery) {
-    if (this._options.objectKey) {
-      delete this._options.objectKey
-    }
-
-    if (reference.list) {
-      this._addListToOutputObj(reference.list)
-    } else {
-      this._addToOutputObj(new this.ReferenceBuilder(reference, this._options, this._csn).build(), false)
-    }
-
-    this._outputObj.sql.push(operator)
-
-    const entityName = subQuery.SELECT.from.ref && subQuery.SELECT.from.ref[0]
-    this._addToOutputObj(
-      new this.SelectBuilder(subQuery, { ...this._options, entityName }, this._csn).build(true),
-      true
-    )
-  }
-
-  /**
-   * This method is overridden in sqlite Expression Builder in order to add the required "VALUES" keyword if needed
-   * Make sure to adapt the overridden function as well, if adapting this.
-   */
-  _addListToOutputObj(list) {
-    this._outputObj.sql.push('(')
-
-    for (let i = 0, len = list.length; i < len; i++) {
-      this._expressionElementToSQL(list[i])
-
-      if (len > 1 && i + 1 < len) {
-        this._outputObj.sql.push(',')
-      }
-    }
-
-    this._outputObj.sql.push(')')
-  }
-
-  /**
-   * Handles one expression element at a time.
-   *
-   * @param {string | object} element expression element
-   * @private
-   */
-  _expressionElementToSQL(element) {
-    if (typeof element === 'string') {
-      this._outputObj.sql.push(element.toUpperCase())
-      return
-    }
-
-    if (element instanceof String) {
-      this._outputObj.sql.push(element.toString().toUpperCase())
-      return
-    }
-
-    for (const key in element) {
-      switch (key) {
-        case 'xpr':
-          return this._xprOutputFromElement(element)
-        case 'ref':
-          return this._refOutputFromElement(element)
-        case 'val':
-          return this._valOutputFromElement(element)
-        case 'SELECT':
-          return this._addToOutputObj(
-            new this.SelectBuilder(
-              element,
-              { ...this._options, entityName: element.SELECT.from.ref && element.SELECT.from.ref[0] },
-              this._csn
-            ).build(true),
-            true
-          )
-        case 'func':
-          return this._addToOutputObj(new this.FunctionBuilder(element, this._options, this._csn).build(), false)
-        case 'list':
-          return this._addListToOutputObj(element.list)
-      }
-    }
-
-    throw new Error(`Cannot build SQL. Invalid CQN object provided: ${JSON.stringify(element)}`)
-  }
-
-  _xprOutputFromElement(element) {
-    this._options.objectKey = 'xpr'
-    // new instance of subclass builder
-    this._addToOutputObj(new this.constructor(element, this._options, this._csn).build(), true)
-  }
-
-  /**
-   * Columns come as an Object with a ref property.
-   *
-   * @param {object} element reference object
-   * @param {object} value only defined for structured
-   * @private
-   */
-  _refOutputFromElement(element) {
-    this._addToOutputObj(new this.ReferenceBuilder(element, this._options, this._csn).build(), false)
-  }
-
-  /**
-   * Instead of adding the value to the SQL via string literal or string concat, add a placeholder instead.
-   * The placeholder is than used by a db driver and prepared statements to defend against injections.
-   *
-   * @param {object} element
-   * @private
-   */
-  _valOutputFromElement(element) {
-    const _outputObj = this._outputObj
-    _outputObj.sql.push(this._options.placeholder)
-    _outputObj.values.push(element.val)
-  }
-
-  _addToOutputObj({ sql, values }, addBrackets) {
-    this._outputObj.sql.push(addBrackets ? `( ${sql} )` : sql)
-    this._outputObj.values.push(...values)
-  }
-}
-
-/*
- * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
- */
-module.exports = ExpressionBuilder

package/libx/_runtime/db/sql-builder/FunctionBuilder.js

@@ -1,232 +0,0 @@
-const BaseBuilder = require('./BaseBuilder')
-
-const cqn2sqlFunc = {
-  toupper: 'upper',
-  tolower: 'lower',
-  indexof: 'locate',
-  day: 'dayofmonth',
-  date: 'to_date',
-  time: 'to_time',
-  average: 'avg'
-}
-
-/**
- * FunctionBuilder is used to take a part of a CQN object as an input and to build an object representing a function
- * with SQL string and values.
- *
- */
-class FunctionBuilder extends BaseBuilder {
-  get ReferenceBuilder() {
-    const ReferenceBuilder = require('./ReferenceBuilder')
-    Object.defineProperty(this, 'ReferenceBuilder', { value: ReferenceBuilder })
-    return ReferenceBuilder
-  }
-
-  get ExpressionBuilder() {
-    const ExpressionBuilder = require('./ExpressionBuilder')
-    Object.defineProperty(this, 'ExpressionBuilder', { value: ExpressionBuilder })
-    return ExpressionBuilder
-  }
-
-  get SelectBuilder() {
-    const SelectBuilder = require('./SelectBuilder')
-    Object.defineProperty(this, 'SelectBuilder', { value: SelectBuilder })
-    return SelectBuilder
-  }
-
-  build() {
-    this._outputObj = {
-      sql: [],
-      values: []
-    }
-
-    this._handleFunction()
-
-    this._outputObj.sql = this._outputObj.sql.join(' ')
-    return this._outputObj
-  }
-
-  _functionName() {
-    const funcName = ((this._obj.ref && this._obj.ref[0]) || this._obj.func).toLowerCase()
-    return cqn2sqlFunc[funcName] || funcName
-  }
-
-  _functionArgs() {
-    return (this._obj.func && this._obj.args) || (this._obj.ref && this._obj.ref[1] && this._obj.ref[1].args)
-  }
-
-  _escapeLikeParameters(parameters) {
-    return parameters.map(parameter => {
-      if (parameter.val) return { ...parameter, val: parameter.val.replace(/(\^|_|%)/g, '^$1') }
-      if (parameter.func) {
-        return { ...parameter, args: this._escapeLikeParameters(parameter.args) }
-      }
-      return parameter
-    })
-  }
-
-  _handleFunction() {
-    const functionName = this._functionName()
-    const args = this._functionArgs()
-
-    if (this._obj.func === 'indexof') {
-      this._handleIndexof(args, functionName)
-      return
-    }
-
-    if (!args) {
-      // > arg-less func such as current_date
-      this._outputObj.sql.push(functionName)
-      return
-    }
-
-    if (functionName.includes('contains')) {
-      // this method is overridden in hana custom function builder
-      // be careful with renaming or changing signature
-      this._handleContains(args)
-      return
-    }
-
-    if (functionName.includes('startswith') || functionName.includes('endswith')) {
-      this._handleLikewiseFunc(args)
-      return
-    }
-
-    if (functionName === 'concat') {
-      this._addFunctionArgs(args, true, ' || ')
-      return
-    }
-
-    if (functionName === 'countdistinct') {
-      this._handleCountdistinct(args)
-      return
-    }
-
-    this._outputObj.sql.push(functionName, '(')
-    if (typeof args === 'string') this._outputObj.sql.push(args)
-    else this._addFunctionArgs(args)
-    this._outputObj.sql.push(')')
-  }
-
-  _handleCountdistinct(args) {
-    this._outputObj.sql.push('count', '(', 'DISTINCT')
-    if (typeof args === 'string') this._outputObj.sql.push(args)
-    else this._addFunctionArgs(args)
-    this._outputObj.sql.push(')')
-  }
-
-  _handleContains(args) {
-    this._handleLikewiseFunc(args)
-  }
-
-  _handleIndexof(args, funcName) {
-    this._outputObj.sql.push('(')
-    this._outputObj.sql.push(funcName, '(')
-    if (typeof args === 'string') this._outputObj.sql.push(args)
-    else this._addFunctionArgs(args)
-    this._outputObj.sql.push(')')
-    this._outputObj.sql.push('-')
-    this._outputObj.sql.push('1')
-    this._outputObj.sql.push(')')
-  }
-
-  _handleLikewiseFunc(args) {
-    const functionName = this._functionName()
-    const not = functionName.startsWith('not') ? 'NOT ' : ''
-    const columns = this._columns(args)
-    const params = this._escapeLikeParameters(args.slice(1))
-
-    const _pattern = (() => {
-      if (functionName.includes('contains')) return _ => ["'%'", _, "'%'"]
-      if (functionName.includes('startswith')) return _ => [_, "'%'"]
-      if (functionName.includes('endswith')) return _ => ["'%'", _]
-    })()
-
-    for (const param of params) {
-      if (param === 'or' || param === 'and' || param === 'not') {
-        this._outputObj.sql.push(param)
-      } else {
-        this._createLikeComparison(not, columns, _pattern(param))
-      }
-    }
-  }
-
-  _createLikeComparison(not, columns, param) {
-    const length = columns.length
-    this._outputObj.sql.push('(')
-
-    for (let i = 0; i < length; i++) {
-      const { sql, values } = new this.ExpressionBuilder([columns[i]], this._options, this._csn).build()
-      if (!sql) continue
-      this._outputObj.values.push(...values)
-      this._createLikeComparisonForColumn(not, sql, param)
-      if (i !== columns.length - 1 && columns[i + 1] !== ')') {
-        this._outputObj.sql.push(not ? 'AND' : 'OR')
-      }
-    }
-
-    this._outputObj.sql.push(')')
-  }
-
-  _createLikeComparisonForColumn(not, left, right) {
-    if (not) {
-      this._outputObj.sql.push('(', left, 'IS NULL', 'OR')
-    }
-
-    this._outputObj.sql.push(left, `${not}LIKE`)
-    this._addFunctionArgs(right, true, ' || ')
-    this._outputObj.sql.push('ESCAPE', "'^'")
-    if (not) this._outputObj.sql.push(')')
-  }
-
-  _columns(args) {
-    return args[0].xpr || args[0].list || [args[0]]
-  }
-
-  _addFunctionArgs(args, enclose, sep = ', ') {
-    const functionName = this._functionName()
-    if (functionName === 'substring') args[1].val++
-    if (enclose) this._outputObj.sql.push('(')
-    const res = []
-
-    for (const arg of args) {
-      if (arg.ref) {
-        if (arg.cast && arg.cast.type) arg._cast4func = arg.cast
-        const { sql, values } = new this.ReferenceBuilder(arg, this._options, this._csn).build()
-        res.push(sql)
-        this._outputObj.values.push(...values)
-      } else if (arg.func) {
-        // new instance of subclass builder
-        const { sql, values } = new this.constructor(arg, this._options, this._csn).build()
-        res.push(sql)
-        this._outputObj.values.push(...values)
-      } else if (arg.xpr) {
-        const { sql, values } = new this.ExpressionBuilder(arg.xpr, this._options, this._csn).build()
-        res.push(sql)
-        this._outputObj.values.push(...values)
-      } else if (arg.SELECT) {
-        const { sql, values } = new this.SelectBuilder(arg, this._options, this._csn).build(true)
-        res.push(sql)
-        this._outputObj.values.push(...values)
-      } else if (Object.prototype.hasOwnProperty.call(arg, 'val')) {
-        res.push(this._options.placeholder)
-        this._outputObj.values.push(arg.val)
-      } else if (arg.list) {
-        this._addFunctionArgs(arg.list, true)
-        // _addFunctionArgs adds the arguments list already to the output object
-        // in order to have correct comma separation, we need to add empty string to res
-        res.push('')
-      } else if (typeof arg === 'string') {
-        res.push(arg)
-      }
-    }
-
-    this._outputObj.sql.push(res.join(sep))
-    if (enclose) this._outputObj.sql.push(')')
-  }
-}
-
-/*
- * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
- */
-module.exports = FunctionBuilder