@sap/cds 5.4.3 → 5.5.0

package/libx/_runtime/cds-services/statements/Select.js

@@ -1,826 +0,0 @@
-const cds = require('../../cds')
-const Where = require('./Where')
-const { hasBeenCalledError, unexpectedFunctionCallError, invalidFunctionArgumentError } = require('../util/errors')
-const { getEntityNameFromCQN } = require('../../common/utils/entityFromCqn')
-
-const MODEL = Symbol.for('sap.cds.model')
-const fnChain = Symbol.for('sap.cds.fnChain')
-const addedColumns = Symbol.for('sap.cds.addedColumns')
-const ON = Symbol.for('cqn.from.on')
-
-const ORDERS = new Set(['asc', 'desc'])
-
-/**
- * SELECT statement selects values or rows from a specific table.
- *
- * @extends {Where}
- */
-class Select extends Where {
-  constructor() {
-    super('SELECT')
-  }
-
-  /**
-   * Wrapper that allows usages like:
-   * SELECT(['column']).from('Table')
-   * SELECT('column').from('Table')
-   * SELECT.from('Table', ['column'])
-   *
-   * @returns {function(*): Select}
-   */
-  static get select() {
-    const fn = (...args) => {
-      if (Array.isArray(args[0])) {
-        args = args[0]
-      }
-
-      return {
-        from: (entity, columns, model) => {
-          return Select.from(entity, columns && columns.length !== 0 ? args.concat(columns) : args, model)
-        }
-      }
-    }
-
-    fn.from = Select.from
-    fn.one = Select.one
-    fn.distinct = Select.distinct
-
-    return fn
-  }
-
-  /**
-   * Select distinct entries of an entity.
-   *
-   * @param {string|object} entity - entity name or an entity from reflection API or CQN
-   * @param {object} model the reflected CSN model
-   * @returns {Select} this object instance for chaining.
-   * @throws Error if no valid argument entity provided
-   */
-  static distinct(entity, model) {
-    if (!entity) {
-      throw invalidFunctionArgumentError(this[fnChain])
-    }
-
-    const cqn = new Select()
-    cqn[fnChain] = cqn[fnChain].concat('.distinct()')
-    if (model) {
-      Object.defineProperty(cqn, MODEL, { value: model })
-    }
-
-    cqn._parseEntity(entity)
-    return cqn.distinct()
-  }
-
-  /**
-   * Select entries of an entity.
-   *
-   * @param {string|object} entity - entity name or an entity from reflection API or CQN
-   * @param {Array} [columns] Can be either an array or an array in string notation that specifies a list of column names or a function
-   * @param {object} [model] the reflected CSN model
-   * @returns {Select} this object instance for chaining.
-   * @throws Error if no valid argument entity provided
-   */
-  static from(entity, columns, model) {
-    if (!entity) {
-      throw invalidFunctionArgumentError('SELECT.from()')
-    }
-
-    const cqn = new Select()
-    cqn[fnChain] = cqn[fnChain].concat('.from()')
-
-    if (model) Object.defineProperty(cqn, MODEL, { value: model })
-    cqn._parseEntity(entity)
-    cqn._parseColumns(columns, entity)
-
-    return cqn
-  }
-
-  /**
-   * Select one entry of the entity. Can be used in combination with where() or byId().
-   *
-   * @param {string|object} entity - entity name or an entity from reflection API or CQN
-   * @param  {Array} columns Can be either an array that specifies a list of column names or a function
-   * @returns {Select} this object instance for chaining.
-   */
-  static one(entity, columns) {
-    return Select.from(entity, columns)._one()
-  }
-
-  _one() {
-    this[fnChain] = this[fnChain].concat('.one()')
-    this.SELECT.one = true
-    return this
-  }
-
-  _checkHasDraftEntity(entity) {
-    const draftName = `${entity.name}_drafts`
-    const keys = Object.keys(entity.keys)
-    let subSelect = Select.from(draftName).columns([1])
-    subSelect = keys.reduce((select, key) => {
-      if (key !== 'IsActiveEntity') {
-        return subSelect.where([
-          { ref: [entity.name, key] },
-          '=',
-          {
-            ref: [draftName, key]
-          }
-        ])
-      }
-      return subSelect
-    }, subSelect)
-    return subSelect
-  }
-
-  _addSelectColumns(entity) {
-    if (!entity) {
-      entity = getEntityNameFromCQN(this.SELECT.from)
-    }
-
-    if (entity && entity.elements) {
-      this[addedColumns] = true
-      const addAliasToColumns = []
-      for (const column in entity.elements) {
-        if (column === 'DraftAdministrativeData_DraftUUID') continue
-        const e = entity.elements[column]
-        if (e.isAssociation || e.virtual) continue
-        else if (entity._isDraftEnabled && column === 'IsActiveEntity') {
-          addAliasToColumns.push({ val: true, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } })
-        } else if (entity._isDraftEnabled && column === 'HasActiveEntity') {
-          addAliasToColumns.push({ val: false, as: 'HasActiveEntity', cast: { type: 'cds.Boolean' } })
-        } else if (entity._isDraftEnabled && column === 'HasDraftEntity') {
-          addAliasToColumns.push({
-            xpr: ['case', 'when', 'exists', this._checkHasDraftEntity(entity), 'then', 'true', 'else', 'false', 'end'],
-            as: 'HasDraftEntity',
-            cast: { type: 'cds.Boolean' }
-          })
-        } else addAliasToColumns.push({ [column]: column })
-      }
-      if (addAliasToColumns.length > 0) this._parseColumns(addAliasToColumns, entity)
-    }
-  }
-
-  _parseColumnsArray(columns, entity) {
-    if (columns.length === 0) {
-      this._addSelectColumns(entity)
-    }
-    this._parseArray(columns)
-  }
-
-  _parseColumns(columns, entity) {
-    if (columns) {
-      if (Array.isArray(columns)) {
-        this._parseColumnsArray(columns, entity)
-      } else if (typeof columns === 'object' && !this[MODEL]) {
-        Object.defineProperty(this, MODEL, { value: columns })
-      } else if (typeof columns === 'string' && columns.includes('{') && columns.includes('}')) {
-        this.SELECT.columns = []
-        if (columns.includes('.{')) {
-          columns = `{${columns.replace(/{/g, '').replace(/}/g, '')}}`
-        }
-        const res = cds.parse.cql(`SELECT from Entity ${columns.replace(/'/g, '')}`)
-        this._parseArray(res.SELECT.columns)
-      } else {
-        throw invalidFunctionArgumentError(this[fnChain], columns)
-      }
-    } else {
-      this._addSelectColumns(entity)
-    }
-  }
-
-  _parseEntity(entity) {
-    const hasOwnProperty = Object.prototype.hasOwnProperty
-
-    if (typeof entity === 'string' && (entity.includes(':') || entity.includes('['))) {
-      this.SELECT.from = Where.convertPathExpression(entity)
-    } else if (typeof entity === 'string') {
-      this._parseString(entity)
-    } else if (
-      typeof entity === 'object' &&
-      hasOwnProperty.call(entity, 'params') &&
-      Object.keys(entity.params).length !== 0
-    ) {
-      this._fromViewWithParams(entity)
-    } else if (typeof entity === 'object' && hasOwnProperty.call(entity, 'name')) {
-      this._from(entity.name)
-    } else if (
-      typeof entity === 'object' &&
-      (hasOwnProperty.call(entity, 'SELECT') || hasOwnProperty.call(entity, 'SET'))
-    ) {
-      this._fromCQN(entity)
-    } else if (typeof entity === 'object') {
-      this._fromObject(entity)
-    } else {
-      throw invalidFunctionArgumentError(this[fnChain], entity)
-    }
-  }
-
-  _fromObject(entity) {
-    const key = this._getKey(entity)
-    if (key === 'ref') {
-      // TODO: support further types of partial cqns like join.
-      this.SELECT.from = entity
-    } else {
-      this._from(entity[key], key)
-    }
-  }
-
-  /**
-   * Group result by column names
-   *
-   * @param {...string} columns - String representing a column name.
-   * @returns {Select} this object instance for chaining.
-   * @throws Error if invalid parameter columns provided
-   */
-  groupBy(...columns) {
-    this[fnChain] = this[fnChain].concat('.groupBy()')
-    if (columns.length === 0) {
-      throw invalidFunctionArgumentError(this[fnChain])
-    }
-
-    columns.forEach(column => {
-      this._addColumnToGroupBy(column)
-    })
-
-    return this
-  }
-
-  /**
-   *  Used to specify column names in SELECT
-   *
-   * @param {Array | string} columns Can be either a list of arguments, an array or a string for inline structure
-   * @returns {Select} this object instance for chaining.
-   * @throws Error if invalid parameter columns provided
-   */
-  columns(columns) {
-    if (this[addedColumns]) {
-      this.SELECT.columns = []
-    }
-
-    this[fnChain] = this[fnChain].concat('.columns()')
-    if (columns) {
-      if (Array.isArray(columns) || (typeof columns === 'string' && columns.startsWith('{'))) {
-        this._parseColumns(columns)
-      } else {
-        this._parseColumns([...arguments])
-      }
-    }
-    return this
-  }
-
-  /**
-   * Orders result by column names
-   *
-   * @param {string|object} columnName - Column name or object describing the order
-   * @param {string} [order] - sorting order, defaults to asc
-   * @example
-   * orderBy('Author', 'asc')
-   * orderBy('Author asc')
-   * orderBy({Author: 'asc'})
-   * orderBy([{ref: ['Author'], sort: 'asc'}])
-   * orderBy(<any>, ...)
-   * orderBy([<any>, ...])
-   * @returns {Select} this object instance for chaining.
-   * @throws Error if no valid parameter columnName provided
-   */
-  orderBy(columnName, order, ...args) {
-    if (typeof columnName === 'string' && columnName.match(/,/)) {
-      columnName = columnName.split(',').map(ele => ele.trim())
-    }
-
-    if (Array.isArray(columnName) && columnName.length > 1) {
-      for (const each of columnName) this.orderBy(each)
-      return this
-    }
-
-    if (args && args.length > 0) {
-      // > more than two args
-      this.orderBy(columnName)
-      this.orderBy(order)
-      for (const each of args) this.orderBy(each)
-      return this
-    }
-
-    if (order && !ORDERS.has(order)) {
-      // > second arg also an ordering
-      this.orderBy(columnName)
-      this.orderBy(order)
-      return this
-    }
-
-    // cqn partial must be in array
-    if (columnName.ref) columnName = [columnName]
-
-    this[fnChain] = this[fnChain].concat('.orderBy()')
-    if (typeof columnName === 'string') {
-      if (columnName.match(/ /)) [columnName, order] = [...columnName.split(' ')]
-      this._addColumnToOrderBy(columnName, order)
-    } else if (Array.isArray(columnName)) {
-      // cqn partial
-      this.SELECT.orderBy = this.SELECT.orderBy || []
-      this.SELECT.orderBy.push(...columnName)
-    } else if (typeof columnName === 'object') {
-      this._addColumnToOrderByAsObject(columnName)
-    } else {
-      throw invalidFunctionArgumentError(this[fnChain], columnName)
-    }
-
-    return this
-  }
-
-  /**
-   * Add inner join.
-   *
-   * @param tableName - Table name to be used for join.
-   * @param as
-   * @returns {Select} this object instance for chaining.
-   * @throws Error - If where or having was already called.
-   */
-  join(tableName, as) {
-    this[fnChain] = this[fnChain].concat('.join()')
-    return this._join(tableName, as, 'inner')
-  }
-
-  /**
-   * Add left join.
-   *
-   * @param tableName - Table name to be used for join.
-   * @param as
-   * @returns {Select} this object instance for chaining.
-   * @throws Error - If where or having was already called.
-   */
-  leftJoin(tableName, as) {
-    this[fnChain] = this[fnChain].concat('.leftJoin()')
-    return this._join(tableName, as, 'left')
-  }
-
-  /**
-   * Add right join.
-   *
-   * @param tableName - Table name to be used for join.
-   * @param as
-   * @returns {Select} this object instance for chaining.
-   * @throws Error - If where or having was already called.
-   */
-  rightJoin(tableName, as) {
-    this[fnChain] = this[fnChain].concat('.rightJoin()')
-    return this._join(tableName, as, 'right')
-  }
-
-  /**
-   * Add full join.
-   *
-   * @param tableName - Table name to be used for join.
-   * @param as
-   * @returns {Select} this object instance for chaining.
-   * @throws Error - If where or having was already called.
-   */
-  fullJoin(tableName, as) {
-    this[fnChain] = this[fnChain].concat('.fullJoin()')
-    return this._join(tableName, as, 'full')
-  }
-
-  /**
-   * .on can only be used after .join has been called.
-   *
-   * @param {Array | object} arg1 Can be object predicate if argument is passed as an object. Or can be array of partial CQNs.
-   * @param {*} [args] Can be strings, values or objects. To be parsed as fluent expression.
-   * @returns {Select} this object instance for chaining.
-   * @throws Error - If called without calling join before.
-   */
-  on(...args) {
-    this[fnChain] = this[fnChain].concat('.on()')
-    if (!Object.prototype.hasOwnProperty.call(this.cqn.from, 'join')) {
-      throw unexpectedFunctionCallError('.on()', '.join()')
-    }
-    this.cqn.from.on = []
-    // eslint-disable-next-line dot-notation
-    if (!this.cqn[ON]) {
-      const that = this
-      Object.defineProperty(this.cqn, ON, {
-        get: () => that.cqn.from.on
-      })
-    }
-    return this._condition(ON, ...args)
-  }
-
-  /**
-   * Add having. Can not be called before .where.
-   *
-   * Possible uses:
-   * having('ID', '<operator>', <value>)
-   * having('ID', 'between', <value>, <value>)
-   * having('Association.name', '<operator>', <value>)
-   * having('lower(column)', '<operator>', <value>)
-   * having(<object>)
-   * Fluid usage with alternating string value arguments
-   * having(arg1, arg2, arg3, ...)
-   * Array with partial CQNs
-   * having([arg1, arg2, arg3, ...])
-   *
-   * @param arg1
-   * @param arg2
-   * @param arg3
-   * @param arg4
-   * @example
-   * having('ID', '>', 7411)
-   * having({ ID: 7411})
-   * having({ or: [{ ID: 7411}, { ID: 2511}]})
-   * Fluid usage:
-   * having(`name like`, 'foo', `and ( ratio between`, 0.1, `and`, 0.3, `or ratio >`, 0.9, ')')
-   * Array with partial CQNs
-   * having([{ref: ['x']}, '=', {val: 1}])
-   *
-   * @returns {Select} this object instance for chaining.
-   * @throws Error - If called more than once or with no arguments or in the wrong context
-   */
-  having(arg1, arg2, arg3, arg4) {
-    if (!arg1) {
-      throw invalidFunctionArgumentError(this[fnChain].concat('.having()'))
-    }
-
-    const cqn = this.cqn
-    if (cqn.having) {
-      return this._andHaving(...arguments)
-    }
-
-    this[fnChain] = this[fnChain].concat('.having()')
-    cqn.having = []
-    return this._having(...arguments)
-  }
-
-  _having(...args) {
-    return this._condition('having', ...args)
-  }
-
-  _andHaving(...args) {
-    return this._setAndOrBracket('and', 'having', ...args)
-  }
-
-  /**
-   * Add distinct.
-   *
-   * @returns {Select} this object instance for chaining.
-   * @throws Error - If called more than once
-   */
-  distinct() {
-    this[fnChain] = this[fnChain].concat('.distinct()')
-    const cqn = this.cqn
-    if (cqn.distinct) {
-      throw hasBeenCalledError('distinct()', this[fnChain])
-    }
-    cqn.distinct = true
-
-    return this
-  }
-
-  /**
-   * Locks the entity until the transaction is ended.
-   * Timeout will unlock entity in case select for update fails and entity is not unlocked on error.
-   *
-   * @param {object} [args={}]
-   * @param {Array} [args.of] Array of string values, that specifies the columns/tables that should be locked
-   * @param {number} [args.wait] An integer value, that specifies when to return an error if a lock can't be obtained on
-   * a record
-   * @returns {this}
-   */
-  forUpdate({ of, wait } = {}) {
-    const cqn = this.cqn
-    cqn.forUpdate = {}
-
-    if (of) {
-      cqn.forUpdate.of = this._getSelectForUpdateOf(of)
-    }
-
-    if (Number.isInteger(wait)) {
-      cqn.forUpdate.wait = wait
-    }
-
-    return this
-  }
-
-  /**
-   * Add limit.
-   *
-   * @param {number} rows - the number of records to return
-   * @param {number} [offset] - skip that many rows before beginning to return rows
-   * @returns {Select} this object instance for chaining.
-   * @throws Error - If called more than once or if invalid parameter rows provided
-   */
-  limit(rows, offset) {
-    this[fnChain] = this[fnChain].concat('.limit()')
-    if (!rows && rows !== 0) {
-      throw invalidFunctionArgumentError(this[fnChain], rows)
-    }
-
-    const cqn = this.cqn
-
-    if (cqn.limit) {
-      throw hasBeenCalledError('limit()', this[fnChain])
-    }
-
-    cqn.limit = { rows: { val: rows } }
-    if (offset) {
-      cqn.limit.offset = { val: offset }
-    }
-
-    return this
-  }
-
-  _join(tableName, as, kind) {
-    if (!tableName) {
-      throw invalidFunctionArgumentError(this[fnChain])
-    }
-
-    if (this.cqn.where) {
-      throw unexpectedFunctionCallError('.where()', '.join()')
-    }
-
-    if (this.cqn.having) {
-      throw unexpectedFunctionCallError('.having()', '.join()')
-    }
-
-    const parts = tableName.split(' ')
-    let ref
-
-    if (parts.length === 3 && parts[1].toUpperCase() === 'AS') {
-      ref = this._parseCastedElement(parts[0], parts[2])
-    } else {
-      ref = { ref: [parts[0]] }
-
-      if (as) {
-        ref.as = as
-      }
-    }
-
-    if (Object.prototype.hasOwnProperty.call(this.cqn.from, 'join')) {
-      this.cqn.from = { join: kind, args: [this.cqn.from, ref] }
-      return this
-    }
-
-    const from = this.cqn.from
-    this.cqn.from = { join: kind, args: [from, ref] }
-
-    return this
-  }
-
-  _getSelectForUpdateOf(columns) {
-    this[fnChain] = this[fnChain].concat('.forUpdate()')
-
-    if (!Array.isArray(columns)) {
-      throw invalidFunctionArgumentError(this[fnChain], columns)
-    }
-
-    const ofCQN = []
-    for (const column of columns) {
-      if (typeof column === 'string') {
-        ofCQN.push(column.includes('.') ? this._parseElementWithDot(column) : { ref: [column] })
-      } else {
-        throw invalidFunctionArgumentError(this[fnChain], columns)
-      }
-    }
-
-    return ofCQN
-  }
-
-  _parseString(entity) {
-    if (entity === '') {
-      throw invalidFunctionArgumentError(this[fnChain])
-    }
-
-    const parsed = this._parseStringElement(entity)
-    this._from(parsed.ref[0], parsed.as)
-  }
-
-  _from(entityName, asName) {
-    this.SELECT.from = { ref: [entityName] }
-
-    if (asName) {
-      this.SELECT.from.as = asName
-    }
-  }
-
-  _fromCQN(cqn) {
-    this.SELECT.from = cqn
-
-    if (cqn.SET && cqn.SET.as) {
-      this.SELECT.as = cqn.SET.as
-      delete cqn.SET.as
-    }
-  }
-
-  _fromViewWithParams(entity, asName) {
-    this.SELECT.from = { ref: [{ id: entity.name }] }
-
-    if (asName) {
-      this.SELECT.from.as = asName
-    }
-  }
-
-  _addColumnToOrderByAsObject(columnObject) {
-    this._extractKeysAndValuesFromObject(columnObject).forEach(item => {
-      this._addColumnToOrderBy(item.key, item.value)
-    })
-  }
-
-  _extractKeysAndValuesFromObject(object) {
-    const array = []
-
-    for (const key in object) {
-      array.push({ key: key, value: object[key] })
-    }
-
-    return array
-  }
-
-  _addColumnToOrderBy(column, order = 'asc') {
-    let res
-
-    if (this._isFunction(column)) {
-      res = this._parseFunction(column)
-    } else {
-      res = column.includes('.') ? this._parseElementWithDot(column) : { ref: [column] }
-    }
-
-    if (Object.prototype.hasOwnProperty.call(this.SELECT, 'orderBy')) {
-      this.SELECT.orderBy.push(res)
-    } else {
-      this.SELECT.orderBy = [res]
-    }
-
-    if (order === 'desc') {
-      this.SELECT.orderBy[this.SELECT.orderBy.length - 1].sort = 'desc'
-    } else if (order === 'asc') {
-      this.SELECT.orderBy[this.SELECT.orderBy.length - 1].sort = 'asc'
-    } else {
-      throw invalidFunctionArgumentError(this[fnChain], column)
-    }
-  }
-
-  _addColumnToGroupBy(column) {
-    const res =
-      typeof column === 'string' && column.includes('.') ? this._parseElementWithDot(column) : { ref: [column] }
-
-    if (Object.prototype.hasOwnProperty.call(this.SELECT, 'groupBy')) {
-      this.SELECT.groupBy.push(res)
-    } else {
-      this.SELECT.groupBy = [res]
-    }
-  }
-
-  _parseArray(columns) {
-    if (!this.SELECT.columns) {
-      this.SELECT.columns = []
-    }
-
-    for (let i = 0, length = columns.length; i < length; i++) {
-      if (typeof columns[i] === 'string' && Array.isArray(columns[i + 1])) {
-        this.SELECT.columns.push(this._parseElement({ [`expand(${columns[i]})`]: columns[i + 1] }))
-        i++
-      } else if (typeof columns[i] === 'string' && columns[i].includes('.')) {
-        this.SELECT.columns.push(this._parseElementWithDot(columns[i]))
-      } else {
-        this.SELECT.columns.push(this._parseElement(columns[i]))
-      }
-    }
-  }
-
-  _parseElement(element) {
-    if (typeof element === 'string') {
-      return this._parseStringElement(element)
-    }
-
-    if (typeof element === 'object') {
-      return this._parseObjectElement(element)
-    }
-
-    if (this._isNumber(element)) {
-      return this._parseNonCastedElement(element)
-    }
-
-    throw invalidFunctionArgumentError(this[fnChain], element)
-  }
-
-  /**
-   * @param element
-   * @example
-   * COUNT(1) AS count
-   * SUM(number) AS number
-   * COUNT(1)
-   * @private
-   * @returns {object}
-   */
-  _parseStringElement(element) {
-    const parts = element.split(' ')
-
-    if (parts.length === 1) {
-      // cannot be zero
-      return this._parseNonCastedElement(element)
-    }
-
-    if (parts.length === 3 && parts[1].toUpperCase() === 'AS') {
-      return this._parseCastedElement(parts[0], parts[2])
-    }
-
-    throw invalidFunctionArgumentError(this[fnChain], element)
-  }
-
-  /**
-   * @param object
-   * @example
-   * {amount: 'COUNT(1)'}
-   * {amount: 'SUM(number)'}
-   * @private
-   * @returns {object}
-   */
-  _parseObjectElement(object) {
-    const hasOwnProperty = Object.prototype.hasOwnProperty
-    // partial CQN: function calls and binding parameters are refs
-    if (
-      hasOwnProperty.call(object, 'val') ||
-      hasOwnProperty.call(object, 'func') ||
-      hasOwnProperty.call(object, 'ref') ||
-      hasOwnProperty.call(object, 'xpr') ||
-      hasOwnProperty.call(object, 'SELECT')
-    ) {
-      return object
-    }
-
-    const key = this._getKey(object)
-
-    if (key.startsWith('expand(') && Array.isArray(object[key])) {
-      return this._parseExpand(key, object[key])
-    }
-
-    return this._parseCastedElement(key, object[key])
-  }
-
-  _getKey(object) {
-    const key = Object.keys(object)[0]
-
-    if (!key) {
-      throw invalidFunctionArgumentError(this[fnChain], object)
-    }
-
-    return key
-  }
-
-  _parseExpand(expr, elements) {
-    const ref = {
-      ref: [expr.replace(/(^expand\(|\)$)/g, '')]
-    }
-    ref.expand = []
-
-    for (const element of elements) {
-      ref.expand.push(this._parseElement(element))
-    }
-
-    return ref
-  }
-
-  _parseElementWithDot(columnString) {
-    const parsedColumn = {}
-    // split by  ` as ` case insensitive and multiple whitespaces
-    const [column, alias] = columnString.split(/\s+as\s+/gi)
-
-    parsedColumn.ref = column.includes('.{') ? this._matchInline(column) : column.split(/\./)
-
-    if (alias) {
-      parsedColumn.as = alias
-    }
-
-    return parsedColumn
-  }
-
-  _parseCastedElement(element, castedName) {
-    const castedElement = this._parseNonCastedElement(element)
-    castedElement.as = castedName
-    return castedElement
-  }
-
-  /**
-   * @param column
-   * @example
-   * COUNT(1) => {func: 'COUNT', args: '1'}
-   * SUM(number) => {func: 'SUM', args: [{ref: ['number']}]}
-   *
-   * @private
-   * @returns {object}
-   */
-  _parseNonCastedElement(column) {
-    if (this._isNumber(column)) {
-      return { val: column }
-    }
-
-    if (this._isFunction(column)) {
-      return this._parseFunction(column)
-    }
-
-    return { ref: [column] }
-  }
-
-  valueOf() {
-    return `SELECT * FROM ${Select._quoteElement(this.SELECT.from.ref.join('.'))} `
-  }
-}
-
-module.exports = Select