@sap/cds 8.5.1 → 8.6.1

package/lib/ql/cds-ql.js

@@ -1,37 +1,231 @@
-const Query = require('./Query')
-require = path => { // eslint-disable-line no-global-assign
-  const clazz = module.require (path); if (!clazz._api) return clazz
-  const factory = clazz._api()
-  const constructor = Object.assign (function (...args) {
-    if (new.target) return new clazz (...args)  // allows: new SELECT
-    return factory (...args)                   // allows: SELECT(...).from()
-  }, factory)                                 // allows: SELECT.from()
-  constructor.class = clazz
-  return constructor
-}
-
-module.exports = exports = {
-  Query,
-  SELECT: require('./SELECT'),
-  INSERT: require('./INSERT'),
-  UPSERT: require('./UPSERT'),
-  UPDATE: require('./UPDATE'),
-  DELETE: require('./DELETE'),
-  CREATE: require('./CREATE'),
-  DROP:   require('./DROP'),
+const cds = require ('../index')
+
+/**
+ * This is the default export, accessible to users through cds.ql.
+ * It's a function turning given input into an instance of cds.ql.Query.
+ *
+ * - If input is already a Query, it is returned as is.
+ * - If input is a string, it is parsed into a CQN object.
+ * - If input is a CQN object, an instance of the corresponding
+ *   Query subclass is contructed and returned.
+ *
+ * Use it in a cast-like way like this:
+ *
+ * @example
+ *  let q = cds.ql ({ SELECT: { from: {ref:[ Books.name ]} }})
+ *  let q = cds.ql (CQL`SELECT from ${Books}`)
+ *  let q = cds.ql `SELECT from ${Books}`
+ *
+ * @returns { import('./SELECT').class }, or any other subclass of Query; but IntelliSense doen't allow to specify this
+ */
+const ql = module.exports = exports = (q,...etc) => {
+  if (q instanceof Query) return q
+  if (q.raw || typeof q === 'string') return ql (cds.parse.cql(q,...etc))
+  for (let k in q) if (k in ql) return new ql[k](q[k])
+  return q //> no-op
 }
 
-exports.clone = function (q,_) {
-  return Query.prototype.clone.call(q,_)
+// Base class and subclasses for all kinds of queries...
+const Query  = exports.Query = require('./cds.ql-Query');
+exports.SELECT = require('./SELECT')
+exports.INSERT = require('./INSERT')
+exports.UPSERT = require('./UPSERT')
+exports.UPDATE = require('./UPDATE')
+exports.DELETE = require('./DELETE')
+exports.CREATE = require('./CREATE')
+exports.DROP   = require('./DROP')
+
+
+exports.predicate = require('./cds.ql-predicates')
+exports.columns = require('./cds.ql-projections')
+/** @import cqn from './cqn' */
+
+
+/**
+ * Constructs a CXN `{ref}` object from given input, which can be one of:
+ *
+ * - several path segment strings
+ * - a single array of the same
+ * - a tagged template literal in CXL path syntax
+ *
+ * @returns {cqn.ref}
+ */
+exports.ref = function (...ref) {
+  if (ref[0].raw) ref = String.raw(...ref).split('.')
+  return {ref}
 }
 
-exports.query = function (q) {
-  if (q instanceof Query) return q
-  for (let k in q) return k in this ? new this[k](q[k]) : q
+
+/**
+ * Constructs CXN `{val}` object from given input, which can be one of:
+ * - a single `string`, `number`, `boolean`, or `null`
+ * - a tagged template literal in CXL literal syntax
+ *
+ * @example
+ * val(`foo`) //> {val:'foo'}`
+ * val`foo`  //> {val:'foo'}
+ * val`11`   //> {val:11}
+ * val(11)   //> {val:11}
+ *
+ * @returns {cqn.val}
+ */
+exports.val = (...val) => {
+  if (val?.[0]?.raw) val = String.raw(...val)
+  else [val] = val
+  return {val}
+}
+
+
+/**
+ * Constructs a CXN `xpr` object from given input, which can be one of:
+ *
+ * - multiple CXN `expr` objects, or strings representing keywords or operators
+ * - a single array of the same
+ * - a tagged template literal in CXL syntax
+ *
+ * @example
+ * xpr([ref`foo`,'=',val(11)]) //> {xpr:[{ref:['foo']},'=',{val:11}]}
+ * xpr(ref`foo`,'=',val(11))   //> {xpr:[{ref:['foo']},'=',{val:11}]}
+ * xpr`foo = 11`               //> {xpr:[{ref:['foo']},'=',{val:11}]}
+ * xpr`foo`                    //> {xpr:[{ref:['foo']}]}
+ * xpr`'foo'`                  //> {xpr:[{val:'foo'}]}
+ * xpr`11`                     //> {xpr:[{val:11}]}
+ * xpr('=')                    //> {xpr:['=']}
+ * xpr('like')                 //> {xpr:['like']}
+ *
+ * @see {@link ql.expr `expr`}
+ * @returns {cqn.xpr}
+ */
+exports.xpr = (...xpr) => {
+  const x = ql.expr(...xpr)
+  return x.xpr ? x : {xpr:[x]} // always returns an `{xpr}` object
+}
+
+
+/**
+ * Same as {@link ql.xpr `xpr`}, but if the result contains only single
+ * entries these are returned as is.
+ *
+ * @example
+ * expr([ref`foo`,'=',val(11)]) //> {xpr:[{ref:['foo']},'=',{val:11}]}
+ * expr(ref`foo`,'=',val(11))   //> {xpr:[{ref:['foo']},'=',{val:11}]}
+ * expr`foo = 11`               //> {xpr:[{ref:['foo']},'=',{val:11}]}
+ * expr`foo`                    //> {ref:['foo']}
+ * expr`11`                     //> {val:11}
+ *
+ * @returns { cqn.ref & cqn.val & cqn.xpr & cqn.list & cqn.func } the constructed CXN `expr` object.
+ */
+exports.expr = (...xpr) => {
+  const [x] = xpr; if (x?.raw) return cds.parse.expr(...xpr) //> tagged template literal
+  else if (is_array(x)) xpr = x //> entries are supposed to be CXN objects
+  return xpr.length === 1 ? xpr[0] : {xpr} //> single entries are returned as is
+}
+
+
+/**
+ * Constructs a CXN `list` object from given input, with can be one of:
+ *
+ * - multiple CXN `expr` objects, or values turned into `{val}`s, including strings
+ * - a single array of the same
+ *
+ * @example
+ * list([`foo`,11]) //> {list:[{val:'foo'},{val:11}]}
+ * list(`foo`,11)   //> {list:[{val:'foo'},{val:11}]}
+ * expr`'foo',11`   //> {list:[{val:'foo'},{val:11}]}
+ * expr`foo,11`     //> {list:[{ref:['foo']},{val:11}]}
+ *
+ * @see Use {@link ql.expr `expr()`} to get the same via a tagged template literal.
+ * @returns {cqn.list}
+ */
+exports.list = (...args) => {
+  const [x] = args; if (is_array(x)) args = x
+  return { list: args.map (_cqn_or_val) }
+}
+
+
+/**
+ * Constructs a CXN `func` object from given input. The first argument is the
+ * function name, the remaining `args` can the same as in {@link ql.list `list()`},
+ * and are handled the same way.
+ *
+ * @example
+ *   func('substring',[`foo`,1]) //> {func:'substring',args:[{val:'foo'},{val:1}]}
+ *   func('substring',`foo`,1)   //> {func:'substring',args:[{val:'foo'},{val:1}]}
+ *   expr`substring('foo',1)`    //> {func:'substring',args:[{val:'foo'},{val:1}]}
+ *   expr`substring(foo,1)`      //> {func:'substring',args:[{ref:['foo']},{val:1}]}
+ *   expr`substring(foo,1)`      //> {func:'substring',args:[{ref:['foo']},{val:1}]}
+ *
+ * @see Use {@link ql.expr `expr()`} to get the same via a tagged template literal.
+ * @returns {cqn.func}
+ */
+exports.func = (func,...args) => {
+  const [x] = args; if (is_array(x)) args = x
+  return { func, args: args.map (_cqn_or_val) }
+}
+
+
+/** @returns { cqn.ref & cqn.as & cqn.infix &{ columns: cqn.column[] }} */
+exports.nested = (ref, ...args) => {
+  if (ref.raw) return ql.nested (ql.ref(ref,...args))
+  else if (!ref.ref) ref = ql.ref(ref)
+  for (let each of args) {
+    if (each.as || each.where || each.orderBy) ref = {...ref, ...each}
+    else ref.columns = ql.columns(each)
+  }
+  ref.columns ??= ['*']
+  return ref
+}
+
+exports.expand = (...args) => {
+  let { columns, ...rest } = ql.nested (...args)
+  return { ...rest, expand: columns }
+}
+
+exports.inline = (...args) => {
+  let { columns, ...rest } = ql.nested (...args)
+  return { ...rest, inline: columns }
+}
+
+/** @returns {{ where: cqn.xo[] }} */
+exports.where = (...args) => ({where: ql.predicate(...args)})
+
+/** @returns {{ orderBy: cqn.order[] }} */
+exports.orderBy = (...args) => ({orderBy: ql.orders(...args)})
+exports.orders = (...args) => {
+  const [x] = args; if (x.raw) return cds.parse._select('from X order by',args).orderBy
+  if (is_array(x)) args = x
+  else if (is_object(x) && !x.ref) {
+    return Object.entries(x) .map (each => _ordering_term (...each))
+  }
+  return args.map (each => {
+    if (each.ref) return each
+    if (typeof each === 'string') return _ordering_term (...each.split(' '))
+  })
+  function _ordering_term (ref,sort) {
+    const ot = cds.parse.ref(ref)
+    if (sort) ot.sort = sort == 1 ? 'asc' : sort == -1 ? 'desc' : sort
+    return ot
+  }
+}
+
+const _cqn_or_val = x => typeof x === 'object' ? x : {val:x}
+const is_object = x => typeof x === 'object'
+const is_array = Array.isArray
+
+
+/**
+ * Returns a new instance of Query for the given input,
+ * that has the given one as prototype.
+ */
+exports.clone = function (q,_) {
+  return Query.prototype.clone.call(q,_)
 }
 
-exports._reset = ()=>{ // for strange tests only
-  const cds = require('../index')
+/**
+ * For questionable tests only.
+ * @protected @deprecated
+ */
+exports._reset = ()=>{
   const _name = cds.env.sql.names === 'quoted' ? n =>`"${n}"` : n => n.replace(/[.:]/g,'_')
   Object.defineProperty (Query.prototype,'valueOf',{ configurable:1, value: function(kind=this.kind) {
     return `${kind} ${_name(this._target.name)} `

package/lib/ql/{Query.js → cds.ql-Query.js}

@@ -1,16 +1,36 @@
 const { AsyncResource } = require('async_hooks')
 const cds = require('../index')
 
+const cloned = from => from.ref ? { ...from, ref:[...from.ref] } : { ...from }
+const cached = {}
+
+
 class Query {
 
+  /** @private */
+  static init () {
+    const self = this, kind = self.name
+    Object.defineProperty (this.prototype, 'kind', {value:kind})
+    Object.defineProperty (this, 'name', {value:'cds.ql'})
+    return Object.assign (function chimera (x,...etc) {
+      if (!new.target) return self.call (x,...etc)
+      let q = new self; if (x) q[kind] = x
+      return q
+    }, this.API)
+  }
+
+  /** @private to be implemented in subclassed*/
+  static call() {}
+
+  /** @private */
+  get _(){ return this[this.kind] }
+
+
   /**
    * The kind of query, as in CQN's SELECT, INSERT, UPDATE, DELETE, CREATE, DROP.
-   * Overridden in subclasses to return the respective kind.
    */
   get kind() { return this.constructor.name }
-  get _(){ return this[this.kind] }
 
-  constructor(_={}) { this[this.kind] = _ }
 
   /**
    * Note to self: We can't use .as (alias) as that would conflict with
@@ -37,6 +57,7 @@ class Query {
 
   /** Binds this query to be executed with the given service */
   bind (srv) {
+    // TODO: resolve target from srv.entities -> but better do that in .from
     return Object.defineProperty (this,'_srv',{ value:srv, configurable:true, writable:true })
   }
 
@@ -47,59 +68,48 @@ class Query {
     return (r,e) => q.runInAsyncScope (srv.run, srv, this).then (r,e)
   }
 
-  _target4 (...args) {
-    return this._target_ref4 (...args)
+  /** @private */ get _target_ref() { return this._.from } // overridden in subclasses
+  /** @private */ set _target(t) { this._set('_target', t.ref ? {name:t.ref[0]} : t) }
+
+  /** @private */ _target4 (t,...etc) {
+    switch (typeof t) {
+      case 'string': {
+        // NOTE: even though this._target will be {name:ref[0]} this returns the parsed {ref}
+        // NOTE: we need to clone cached refs, as they might get modified afterwards
+        return this._target = cloned (cached[t] ??= cds.parse.path(t))
+      }
+      case 'object': {
+        if (t.raw) return this._target = !etc.length ? this._target4(t[0]) : cds.parse.path(t,...etc)
+        if (t.name) return {ref:[ (this._target = t).name ]}
+        if (t.ref || t.SELECT || t.SET) return this._target = t
+      }
+    }
+    throw this._expected `${{target:t}} to be an entity path string, a CSN definition, a {ref}, a {SELECT}, or a {SET}`
   }
 
-  _target_ref4 (target, arg2) {
-
-    // If called with a linked entity -> use it as this.target
-    if (target instanceof cds.entity) this.target = target
-
-    // REVISIT: this._target is not reliable !!!
-    this._set ('_target', function _target(t) { return t && (
-      typeof t === 'string' ? { name: t } :
-      t.ref ? { name: t.ref[0] } :
-      t.raw ? _target(arg2) :
-      t.SELECT ? _target(t.SELECT.from) :
-      t //> default is assumed to be a csn definition or a look-alike or a SELECT
-    )}(target))
-
-    // Determine from.ref or from.SELECT
-    const from = target && (
-      target.name   ? {ref:[target.name]} :
-      typeof target === 'string' ? cds.parse.path(target) :
-      target.raw    ? cds.parse.path(...arguments) :
-      target.ref    ? target :
-      target.SELECT ? target :
-      target.SET    ? target : 0
-    )
-    return from || this._expected `${{target}} to be an entity path string, a CSN definition, a {ref}, a {SELECT}, or a {SET}`
+  /** @private */ _expected (...args) {
+    return cds.error.expected (...args)
   }
 
-  _expected (...args) {
-    return cds.error.expected (...args)
+  /** @private */ _assign (...aspects) {
+    Object.assign (this._, ...aspects)
+    return this
   }
 
-  _add (property, values) {
+  /** @private */ _add (property, values) {
     const {_} = this, pd = Reflect.getOwnPropertyDescriptor (_,property)
-    _[property] = !pd || !pd.value ? values : [ ...pd.value, ...values ]
+    _[property] = !pd?.value ? values : [ ...pd.value, ...values ]
     return this
   }
 
-  _set (property, value) {
-    Reflect.defineProperty (this, property, { value, configurable:true, writable:true })
-    return value
+  /** @private */ _set (property, value) {
+    return Object.defineProperty (this, property, { value, configurable:true, writable:true })
   }
 
   valueOf (prelude = this.kind) {
     return `${prelude} ${_name(this._target.name)} `
   }
 
-  get _target_ref() {
-    throw cds.error `Query subclass ${this.constructor.name} must implement '_target_ref'`
-  }
-
   /**
    * Returns the inferred query's source, which is the entity referred
    * to in SELECT.from, INSERT.into, UPDATE.entity, or DELETE.from,
@@ -118,8 +128,9 @@ class Query {
    * returns the target of the sub query, recursively.
    */
   get target() {
+    if (this._target instanceof cds.entity) return super.target = this._target
     const m = this._srv?.model || cds.context?.model || cds.model
-    return cds.infer (this, m?.definitions)
+    return this.target = cds.infer (this, m?.definitions)
   }
   set target(t) { this._set('target',t) }
 

package/lib/ql/cds.ql-predicates.js

@@ -0,0 +1,133 @@
+const cds = require('../index')
+module.exports = predicate
+
+
+/** @import cqn from './cqn' */
+/** @returns {cqn.xo[]} */
+function predicate (...args) {
+  const [x] = args
+  if (x) switch (typeof x) {
+    case 'object':
+      if (x.raw) return _ttl(args)
+      if (args.length > 1) return _legacy(...args) //> legacy support for predicate (ref`a`, '=', val`b`)
+      if (is_array(x)) return x
+      if (is_cqn(x)) return [x]
+      else return _qbe(x)
+    case 'string': return _fluid(args)
+    default: return args.map(_val)
+  }
+}
+
+
+function _ttl (args) {
+  const cxn = cds.parse.expr(...args)
+  return cxn.xpr ?? [cxn] //> the fallback is for single-item exprs like `1` or `ref`
+}
+
+
+function _fluid (args) {
+  if (args.length === 3) switch (args[1]) {
+    case '=': case '<': case '<=': case '>': case '>=': case '!=': case '<>': case 'like': case 'in': case 'IN': case 'LIKE':
+      return _legacy (...args)
+  }
+  if (args.length % 2 === 0) args.push('')
+  const expr = args.filter((_, i) => i % 2 === 0).join(' ? ')
+  const vals = args.filter((_, i) => i % 2 === 1)
+  const { xpr } = _pred_expr(expr); (function _fill_in_vals_into (xpr) {
+    xpr.forEach((x, i) => {
+      if (x.xpr) _fill_in_vals_into(x.xpr)
+      if (x.param) xpr[i] = _val(vals.shift())
+    })
+  })(xpr)
+  return xpr
+}
+
+
+function _qbe (o, xpr=[]) {
+
+  let count = 0
+  for (let k in o) { const x = o[k]
+
+    if (k.startsWith('not ')) { xpr.push('not'); k = k.slice(4) }
+    switch (k) { // handle special cases like {and:{...}} or {or:{...}}
+      case 'between':
+        xpr.push('between', _val(x), 'and', _val(o.and))
+        return xpr
+      case 'and': xpr.push(k)
+        x.or ? xpr.push({xpr:_qbe(x)}) : _qbe(x,xpr)
+        continue
+      case 'or':  xpr.push(k)
+        _qbe(x,xpr)
+        continue
+      case 'not': xpr.push(k)
+        if (x && typeof x === 'object') x.in || x.like || x.exists || x.between ? _qbe(x,xpr) : xpr.push({xpr:_qbe(x)})
+        else xpr.push(x === null ? 'null' : {val:x})
+        continue
+      case 'is': xpr.push('is')
+        if (x && typeof x === 'object') _qbe(x,xpr)
+        else xpr.push(x === null ? 'null' : {val:x})
+        continue
+      case 'is not': xpr.push('is','not')
+        if (x && typeof x === 'object') _qbe(x,xpr)
+        else xpr.push(x === null ? 'null' : {val:x})
+        continue
+      case 'exists':
+        xpr.push(k,_ref(x)||x)
+        continue
+      case 'in': case 'IN': // REVISIT: 'IN' is for compatibility only
+        xpr.push(k, x.SELECT ? x : { list: x.map(_val) })
+        continue
+      case '=': case '<': case '<=': case '>': case '>=': case '!=': case '<>': case 'like': case 'LIKE': // REVISIT: 'LIKE' is for compatibility only
+        xpr.push(k,_val(x))
+        continue
+    }
+
+    const a = cds.parse.ref(k)            //> turn key into a ref for the left side of the expression
+    if (count++) xpr.push('and')      //> add 'and' between conditions
+    if (!x || typeof x !== 'object')  xpr.push (a,'=',{val:x})
+    else if (is_array(x))             xpr.push (a,'in',{list:x.map(_val)})
+    else if (x.SELECT || x.list)      xpr.push (a,'in',x)
+    else if (is_cqn(x))               xpr.push (a,'=',x)
+    else if (x instanceof Date)       xpr.push (a,'=',{val:x})
+    else if (x instanceof Buffer)     xpr.push (a,'=',{val:x})
+    else if (x instanceof RegExp)     xpr.push (a,'like',{val:x})
+    else { xpr.push(a); _qbe(x,xpr) } //> recurse into nested qbe
+  }
+  return xpr
+}
+
+
+/** @deprecated */
+const _legacy = (x,o,y) => [ _ref(x)||x, o, _val(y) ]
+
+const _pred_expr = x => {
+  if (typeof x !== 'string') return {val:x}
+  if (x === '*') return x
+  const t = /^\s*([\w.'?]+)(?:\s*([!?\\/:=\-+<~>]+|like)\s*([\w.'?]+))?\s*$/.exec(x)
+  if (!t) return cds.parse.expr(x)
+  const [,lhs,op,rhs] = t
+  return !op ? _ref_or_val(lhs) : {xpr:[ _ref_or_val(lhs), op, _ref_or_val(rhs) ]}
+}
+
+const _ref_or_val = (x) => {
+  if (x[0] === '?')  return { param: true, ref: x }
+  if (x[0] === "'")  return { val: x.slice(1,-1).replace(/''/g, "'") }
+  if (x === 'null')  return { val: null }
+  if (x === 'true')  return { val: true }
+  if (x === 'false') return { val: false }
+  if (!isNaN(x))     return { val: Number(x) }
+  else               return { ref: x.split('.') }
+}
+
+const _ref = x => typeof x === 'string' ? { ref: x.split('.') } : x // if x is a string, turn it into a ref; if not we assume it's a cxn object
+const _val = x => !x ? {val:x} : is_array(x) ? { list: x.map(_val) } : is_cqn(x) ? x : {val:x}
+
+const is_cqn = x => typeof x === 'object' && (
+  'ref' in x ||
+  'val' in x ||
+  'xpr' in x ||
+  'list' in x ||
+  'func' in x ||
+  'SELECT' in x
+)
+const is_array = Array.isArray

package/lib/ql/cds.ql-projections.js

@@ -0,0 +1,111 @@
+const predicate = require('./cds.ql-predicates')
+const cds = require('../index')
+
+/** @import cqn from './cqn' */
+/** @returns {cqn.column[]} */
+module.exports = function projection (...args) {
+  const [x] = args
+  if (x) switch (typeof x) {
+    case 'function':
+      return _function(x)
+    case 'object':
+      if (x.raw) return _ttl(args)
+      if (is_array(x)) return _array(x)
+      break //> processing all args below
+    case 'string':
+      if (x[0] === '{') return _string(x)
+  }
+  return _array (args)
+}
+
+
+function _ttl (args) {
+  if (args[0][0][0] === '{') return cds.parse._select('from X',args).columns
+  return cds.parse._select('',args,'from X').columns
+}
+
+function _string (x) {
+  return cds.parse.cql('SELECT from X '+ x).SELECT.columns
+}
+
+
+function _array (args) {
+  return args.map (column_expr)
+  function column_expr (x) {
+    switch (typeof x) {
+      case 'string': {
+        if (x === '*') return x
+        let alias = /\s+as\s+(\w+)$/i.exec(x)
+        if (alias) return { ...cds.parse.ref(x.slice(0,alias.index)), as: alias[1] }
+        return cds.parse.ref(x)
+      }
+      case 'object': {
+        if (x.name) return { ref: [x.name] } //> reflected element
+        if (is_cqn(x)) return x //> already a CQN object
+        else for (let e in x) return {...cds.parse.ref(e), as: x[e] } //> { element: alias }
+        throw this._expected`Argument for SELECT.columns(${x}) to be a valid column expression`
+      }
+      default: return { val: x }
+    }
+  }
+}
+
+
+function _function (fn) {
+  const columns = []; fn(new Proxy(fn, {
+    apply: (_, __, args) => {
+      if (!args.length) return columns.push('*')
+      let [x] = is_array(args[0]) ? args[0] : args
+      columns.push(x === '*' || x === '.*' ? '*' : is_cqn(x) ? x : { ref: [x] })
+      return { as: (alias) => (x.as = alias) }
+    },
+    get: (_, p) => {
+      const col = { ref: [p] }; columns.push(col)
+      const nested = new Proxy(fn, {
+        get: (_, p) => {
+          if (p === 'where') return (x) => ((col.where = predicate(x)), nested)
+          if (p === 'as') return (alias) => ((col.as = alias), nested)
+          else return col.ref.push(p), nested
+        },
+        apply: (_, __, args) => {
+          const [a, b] = args
+          if (!a) col.expand = ['*']
+          else if (a.raw) switch (a[0]) {
+            case '*': col.expand = ['*']; break
+            case '.*': col.inline = ['*']; break
+            default: {
+              // The ttl is the tail of a column expression including infic filter and nested projection.
+              // So, we need to add the col name as prefix to be able to parse it...
+              const {columns} = cds.parse._select(col.ref.at(-1), args, 'from X')
+              Object.assign(col, columns[0])
+            }
+          }
+          else if (is_array(a)) col.expand = _array(a)
+          else if (a === '*') col.expand = ['*']
+          else if (a === '.*') col.inline = ['*']
+          else if (typeof a === 'string') col.ref.push(a)
+          else if (typeof a === 'function') {
+            let x = (col[/^\(?_\b/.test(a) ? 'inline' : 'expand'] = _function(a))
+            if (b?.levels) while (--b.levels) x.push({ ...col, expand: (x = [...x]) })
+          } else if (typeof b === 'function') {
+            let x = (col[/^\(?_\b/.test(b) ? 'inline' : 'expand'] = _function(b))
+            if (a?.depth) while (--a.depth) x.push({ ...col, expand: (x = [...x]) })
+          }
+          return nested
+        },
+      })
+      return nested
+    },
+  }))
+  return columns
+}
+
+const is_cqn = x => typeof x === 'object' && (
+  'ref' in x ||
+  'val' in x ||
+  'xpr' in x ||
+  'list' in x ||
+  'func' in x ||
+  'SELECT' in x
+)
+const is_array = Array.isArray