@sap/cds-dk 10.1.0 → 10.1.1

package/bin/import.js

@@ -1,9 +1,12 @@
+const { FILE, DIR } = require('./completion')
 module.exports = Object.assign(_import, {
     _name: 'import',
     staticCompletions: () => ({
         '--from': ['asyncapi', 'edmx', 'openapi'],
         '--as':   ['cds', 'csn', 'json'],
-        '_':      { type: ':file', ext: ['json', 'xml', 'edmx'] },
+        '--out':  DIR(),
+        '-o':     DIR(),
+        '_':      FILE('json,xml,edmx'),
     }),
     options:   [ '--services', '--for', '--out', '--as', '--name', '--include-namespaces', '--dependencies', '--from', '--config', '--destination', '--group', '--into-namespace' ],
     shortcuts: [ '-s',            '-4',    '-o',  '-as',     '-n',                  '-ns',             '-d',undefined,       '-c',       undefined, undefined,                '-2',        '-', '-f', '-b'],

package/bin/init.js

@@ -10,6 +10,7 @@ module.exports = Object.assign(init, {
     staticCompletions: () => ({
         '--add':          COMMA(require('../bin/completion/completionFs').readTemplates([])),
         '--java:package': DIR(),
+        '--base':         DIR(),
     }),
     options: ['--add', '--java:mvn', '--java:package', '--lint:custom', '--lint:custom:example', '--no-db', '--base'],
     shortcuts: ['-a'],

package/bin/inspect.js

@@ -9,7 +9,9 @@ const { FILE } = require('./completion');
 module.exports = Object.assign (inspect, {
     staticCompletions: () => ({
         '--kind': ['entity', 'aspect', 'type', 'service'],
-        '_':      FILE('cds,json'),
+        '--list': ['names', 'elements', 'keys', 'associations', 'compositions', 'ids', 'sources', 'all'],
+        '-l':     ['names', 'elements', 'keys', 'associations', 'compositions', 'ids', 'sources', 'all'],
+        '_':      FILE('cds,json', { dirs: true }),
     }),
     options: [ '--stats', '--list', '--kind' ],
   shortcuts: [ '-s', '-l', '-k' ],

package/bin/lint.js

@@ -1,13 +1,15 @@
+const { FILE } = require('./completion')
 const Linter = require('../lib/lint/Linter');
 const linter = new Linter();
 
-// cds cli exec expects an executable object with various additional properties.
-// As most of the linting functionality is bound to a class instance, we need to wrap the instance
-// to not lose the this-context and attach the additional properties to the function.
 const lint = (...args) => linter.lint(...args)
 const additionalProperties = Object.entries(linter.init())
     .map(([key, value]) => [key, { value }])
 
 Object.defineProperties(lint, Object.fromEntries(additionalProperties))
 
+lint.staticCompletions = () => ({
+    '_': FILE('js,ts,cds', { dirs: true }),
+})
+
 module.exports = lint

package/bin/minify.js

@@ -119,4 +119,9 @@ class Dryifier extends Minifier {
   }
 }
 
-module.exports = Object.assign (Minify._for_cds_dk(), { Minify })
+const { FILE } = require('./completion')
+module.exports = Object.assign (Minify._for_cds_dk(), { Minify,
+  staticCompletions: () => ({
+    '_': FILE('cds,json', { dirs: true }),
+  })
+})

package/bin/repl.js

@@ -1,6 +1,15 @@
+const { DIR } = require('./completion');
 module.exports = Object.assign (repl, {
-  options: [ '--run', '--use', '--ql' ],
-  shortcuts: [ '-r', '-u' ],
+  options: [ '--run', '--use' ],
+  flags: [ '--ql' ],
+  shortcuts: ['-r', '-u'],
+  staticCompletions: () => ({
+    '_':     DIR(),
+    '--run': DIR(),
+    '-r':    DIR(),
+    '--use': ['xl', 'ql', 'entities', 'services'],
+    '-u':    ['xl', 'ql', 'entities', 'services'],
+  }),
   help: `
 # SYNOPSIS
 

package/bin/run.js

@@ -1,6 +1,17 @@
+const { DIR } = require('./completion');
 const serve = require ('./serve')
 module.exports = Object.assign (
-    cds_run, serve, {help: `
+    cds_run, serve, {
+    staticCompletions: () => ({
+        '_':       DIR(),
+        '--from':  DIR(),
+        '-f':      DIR(),
+        '--with':  DIR(),
+        '-w':      DIR(),
+        '--to':    ['odata', 'fiori', 'rest'],
+        '-2':      ['odata', 'fiori', 'rest'],
+    }),
+    help: `
 # SYNOPSIS
 
     *cds run* [<project>] [<options>]

package/bin/serve.js

@@ -1,6 +1,17 @@
 // allows executing `cds serve` even when `cds` executable is removed from `@sap/cds`
-
-module.exports = require(_local('@sap/cds/bin/serve'))
+const { DIR } = require('./completion');
+const serve = require(_local('@sap/cds/bin/serve'))
+module.exports = Object.assign(serve, {
+  staticCompletions: () => ({
+    '_':      DIR(),
+    '--from': DIR(),
+    '-f':     DIR(),
+    '--with': DIR(),
+    '-w':     DIR(),
+    '--to':   ['odata', 'fiori', 'rest'],
+    '-2':     ['odata', 'fiori', 'rest'],
+  }),
+})
 
 function _local (id) {
   return require.resolve (id, { paths: [ process.cwd(), __dirname ] })

package/bin/up.js

@@ -1,6 +1,9 @@
+const { FILE } = require('./completion');
+
 module.exports = Object.assign(up, {
   staticCompletions: () => ({
-      '--to': ['cf', 'k8s'],
+      '--to':      ['cf', 'k8s'],
+      '--overlay': FILE('mtaext')
   }),
   options: ['--to', '--namespace', '--overlay'],
   shortcuts: ['-2', '-n'],

package/bin/util/containerize.js

@@ -59,6 +59,7 @@ function processCommands(bp) {
 }
 function processBuildpack(bp, name, tag, clearCache = false, image, publish = false) {
   let { type, path, env, builder } = bp.buildpack
+  const dependencyMirrors = Object.keys(process.env).filter(key => key.startsWith('BP_DEPENDENCY_MIRROR_') && process.env[key])
   type = type ? type.split(',').map(t => buildpacks.has(t.trim()) ? `paketo-buildpacks/${t.trim()}` : t.trim()) : []
   if (builders.has(builder)) builder = `paketobuildpacks/${builder}`
   const cacheArgs = clearCache ? ['--clear-cache'] : []
@@ -69,6 +70,7 @@ function processBuildpack(bp, name, tag, clearCache = false, image, publish = fa
     ...type.flatMap(t => appendSubcommand(t, '--buildpack')),
     ...appendSubcommand(builder, '--builder'),
     ...appendSubcommand(env, '--env'),
+    ...dependencyMirrors.flatMap(key => ['--env', key]),
     ...(publish ? ['--publish'] : []),
     ...cacheArgs
   ]]

package/bin/watch/index.js

@@ -3,10 +3,17 @@ const { DIR } = require('../completion')
 
 module.exports = Object.assign ( watch, {
   staticCompletions: () => ({
+    '_':                         DIR(),
+    '--from':                    DIR(),
+    '-f':                        DIR(),
+    '--with':                    DIR(),
+    '-w':                        DIR(),
+    '--to':                      ['odata', 'fiori', 'rest'],
+    '-2':                        ['odata', 'fiori', 'rest'],
     '--experimental-hot-reload': ['true', 'false'],
     '--livereload':              ['false'],
     '--include':                 DIR(),
-    '--exclude':                 DIR(),
+    '--exclude':                 DIR()
   }),
   flags: [ '--in-memory', '--in-memory?', '--with-mocks', '--with-mtx' ],
   options: [ '--port', ...watchOnlyOptions ],

package/lib/build/util.js

@@ -8,7 +8,6 @@ const { exists } = cds.utils
 const execAsync = require('node:util').promisify(cp.exec)
 const { isRoot } = require('../util/fs')
 
-const IS_WIN = require('node:os').platform() === 'win32'
 const { SEVERITY_ERROR, FILE_EXT_CDS, NODEJS_MODEL_EXCLUDE_LIST } = require('./constants');
 const DEBUG = cds.debug('cli|build')
 
@@ -288,7 +287,7 @@ const _cachedWsRoots = new Map()
  * could contain globs. Glob resolution will be supported.
  * The result is cached by workspace root!
  * natively in the future (fs.glob is in experimental state as of Node23).
- * @param {import('fs').PathLike} wsRoot - the root directory of the workspace
+ * @param {string} wsRoot - the root directory of the workspace
  * @returns {Promise<string[]>} list of package paths, or an empty array if either
  * no workspaces are defined or have not been installed.
  */
@@ -302,8 +301,7 @@ async function _execNpmWs(wsRoot) {
     try {
         const cmdLine = 'npm ls --ws --json'
         DEBUG?.(`execute ${cmdLine}`)
-        // @ts-expect-error - TODO: shell should be a string. But can probably be removed altogether?
-        const { stdout } = await execAsync(cmdLine, { shell: IS_WIN, stdio: ['inherit', 'pipe', 'inherit'], cwd: wsRoot })
+        const { stdout } = await execAsync(cmdLine, { cwd: wsRoot })
         const jsonResult = JSON.parse(stdout)
         if (jsonResult.dependencies) {
             result = Object.keys(jsonResult.dependencies)

package/lib/init/constants.js

@@ -5,7 +5,7 @@ module.exports = {
     COMMAND_ADD: 'add',
 
     JAVA_LTS_VERSIONS: [25],
-    MAVEN_ARCHETYPE_VERSION: '5.0.1',
+    MAVEN_ARCHETYPE_VERSION: '5.1.1',
 
     OPTIONS: Object.freeze({
         COMPLETION: 'completion',

package/lib/init/template/data/as-json.js

@@ -247,6 +247,9 @@ function dataForField(element, artifact, csn, record, data, parent, depth, refer
       const range = { from: 0, to: prec }
       annotatedIntRange(element, range)
       if (scale === 0) return randomIntInRange(range)
+      const factor = Math.pow(10, scale)
+      range.from = Math.ceil(range.from * factor) / factor
+      range.to = Math.floor(range.to * factor) / factor
       // draw uniformly across the range and round to scale, so annotated bounds are never exceeded
       const val = +randomDecimalInRange(range).toFixed(scale)
       return +Math.min(Math.max(val, range.from), range.to).toFixed(scale)

package/node_modules/@cap-js/db-service/CHANGELOG.md

@@ -4,6 +4,23 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [3.1.0](https://github.com/cap-js/cds-dbs/compare/db-service-v3.0.1...db-service-v3.1.0) (2026-09-07)
+
+
+### Added
+
+* rank $search results by relevance ([#1725](https://github.com/cap-js/cds-dbs/issues/1725)) ([bc93160](https://github.com/cap-js/cds-dbs/commit/bc931601a721f7c9e00b89e6844ba064352b541d))
+
+
+### Fixed
+
+* **cqn4sql:** reject overly nested query expressions instead of crashing ([#1712](https://github.com/cap-js/cds-dbs/issues/1712)) ([29a45b7](https://github.com/cap-js/cds-dbs/commit/29a45b7daadbc77433b882148700d73c00efae62))
+* don't throw when releasing/destroying a resource that's no longer in the pool ([#1696](https://github.com/cap-js/cds-dbs/issues/1696)) ([5d3b277](https://github.com/cap-js/cds-dbs/commit/5d3b277a1cf7cac02e41f2f24975a8e9473e5b5e))
+* exclude cds.Vector from wildcard select expansion ([#1716](https://github.com/cap-js/cds-dbs/issues/1716)) ([398bacc](https://github.com/cap-js/cds-dbs/commit/398bacc2a74883dcd93acba288deae362570a4c1))
+* INSERT.from(SELECT) used non-existent `value`  ([#1565](https://github.com/cap-js/cds-dbs/issues/1565)) ([fd98844](https://github.com/cap-js/cds-dbs/commit/fd98844c83a78d6cf2b0b71344d3ee1d88528106))
+* **pool:** recover lost connection after stale acquire timeout ([#1724](https://github.com/cap-js/cds-dbs/issues/1724)) ([cf6af99](https://github.com/cap-js/cds-dbs/commit/cf6af991d02be7cf5f861e2a424d4d733b8f9238))
+* pql groupby path expression ([#1700](https://github.com/cap-js/cds-dbs/issues/1700)) ([82b5e03](https://github.com/cap-js/cds-dbs/commit/82b5e0385e680321f30c352f0f78ade6d25259a6))
+
 ## [3.0.1](https://github.com/cap-js/cds-dbs/compare/db-service-v3.0.0...db-service-v3.0.1) (2026-06-29)
 
 

package/node_modules/@cap-js/db-service/lib/common/generic-pool.js

@@ -150,7 +150,7 @@ constructor (factory, options = {}) {
       return
     }
     const loan = this._loans.get(resource)
-    if (!loan) throw new Error('Resource not currently part of this pool')
+    if (!loan) return
     this._loans.delete(resource)
     const pooledResource = loan.pooledResource
     pooledResource.idle()
@@ -164,7 +164,7 @@ constructor (factory, options = {}) {
       return
     }
     const loan = this._loans.get(resource)
-    if (!loan) throw new Error('Resource not currently part of this pool')
+    if (!loan) return
     this._loans.delete(resource)
     const pooledResource = loan.pooledResource
     await this.#destroy(pooledResource)
@@ -212,16 +212,13 @@ constructor (factory, options = {}) {
       for (let i = 0; i < needed; i++) this.#createResource()
     }
     const dispense = async resource => {
-      const request = this._queue.shift()
+      let request = this._queue.shift()
+      while (request && request.state !== RequestState.PENDING) request = this._queue.shift()
       if (!request) {
         resource.idle()
         this._available.add(resource)
         return false
       }
-      if (request.state !== RequestState.PENDING) {
-        this.#dispense()
-        return false
-      }
       this._loans.set(resource.obj, { pooledResource: resource })
       resource.update(ResourceState.ALLOCATED)
       request.resolve(resource.obj)

package/node_modules/@cap-js/db-service/lib/cqn2pql.js

@@ -18,7 +18,7 @@ class CQN2PQLRenderer extends CQN2SQL {
 
   column_expr(x, q) {
     // omit alias when target is a single source
-    if (q.SELECT.from.ref && x?.ref) x.ref = x.ref.slice(-1)
+    if (q.SELECT.from?.ref && x?.ref) x.ref = x.ref.slice(-1)
     return super.column_expr(x, q)
   }
 

package/node_modules/@cap-js/db-service/lib/cqn2sql.js

@@ -1088,7 +1088,7 @@ class CQN2SQLRenderer {
 
     const extractions = this._managed = this.managed(columns.map(c => ({ name: c, sql: `NEW.${this.quote(c)}` })), elements)
     const sql = extractions.length > columns.length
-      ? `SELECT ${extractions.map(c => `${c.insert} AS ${this.quote(c.name)}`)} FROM (${this.SELECT(src)}) AS NEW`
+      ? `SELECT ${extractions.map((c, i) => `${i < columns.length ? c.insert : c.onInsert} AS ${this.quote(c.name)}`)} FROM (${this.SELECT(src)}) AS NEW`
       : this.SELECT(src)
     if (extractions.length > columns.length) columns = this.columns = extractions.map(c => c.name)
     this.sql = `INSERT INTO ${this.quote(entity)}${alias ? ' as ' + this.quote(alias) : ''} (${columns.map(c => this.quote(transitions.mapping.get(c)?.ref?.[0] || c))}) ${sql}`
@@ -1161,12 +1161,12 @@ class CQN2SQLRenderer {
       const extractions = this._managed
       if (this.values) this.values = [] // Clear previously computed values
       const src = this.cqn4sql(UPSERT.from || UPSERT.as)
-      const aliasedQuery = cds.ql.SELECT
-        .columns(src.SELECT.columns
-          .map((c, i) => ({ ref: [this.column_name(c)], as: this.columns[i] }))
-        )
-        .from(src)
-      sql = `SELECT ${extractions.map(c => `${c.upsert}`)} FROM (${this.SELECT(aliasedQuery)}) AS NEW LEFT JOIN ${this.quote(entity)} AS OLD ON ${keyCompare}`
+      const aliasedQuery = `SELECT ${[
+        ...src.SELECT.columns.map((c, i) => this.column_expr({ ref: [this.column_name(c)], as: this.columns[i] })),
+        ...extractions.slice(src.SELECT.columns.length).map(c => `${elements[c.name].key ? c.onInsert : 'NULL'} AS ${this.quote(c.name)}`), // fill in missing default values
+      ]} FROM (${this.SELECT(src)})`
+
+      sql = `SELECT ${extractions.map(c => elements[c.name].key ? `NEW.${this.quote(c.name)}` : c.upsert)} FROM(${aliasedQuery}) AS NEW LEFT JOIN ${this.quote(entity)} AS OLD ON ${keyCompare} `
       if (extractions.length > columns.length) columns = this.columns = extractions.map(c => c.name)
       this.entries = [this.values]
     }
@@ -1574,9 +1574,11 @@ class CQN2SQLRenderer {
 
   managed_extract(name, element, converter) {
     const { UPSERT, INSERT } = this.cqn
-    const extract = !(INSERT?.entries || UPSERT?.entries) && (INSERT?.rows || UPSERT?.rows)
-      ? `value->>${this.string(`$[${this.columns.indexOf(name)}]`)}`
-      : `value->>${this.string(`$.${JSON.stringify(name)}`)}`
+    const extract = (INSERT?.entries || UPSERT?.entries)
+      ? `value->>${this.string(`$.${JSON.stringify(name)}`)}`
+      : (INSERT?.rows || UPSERT?.rows)
+        ? `value->>${this.string(`$[${this.columns.indexOf(name)}]`)}`
+        : `NEW.${this.quote(name)}` // in case of (INSERT?.from || UPSERT?.from)
     const sql = converter?.(extract) || extract
     return { extract, sql }
   }
@@ -1587,7 +1589,9 @@ class CQN2SQLRenderer {
   }
 
   managed_default(name, managed, src) {
-    return `(CASE WHEN json_type(value,${this.managed_extract(name).extract.slice(8)}) IS NULL THEN ${managed} ELSE ${src} END)`
+    const { UPSERT, INSERT } = this.cqn
+    const isJson = INSERT?.entries || UPSERT?.entries || INSERT?.rows || UPSERT?.rows
+    return `(CASE WHEN ${isJson ? `json_type(value,${this.managed_extract(name).extract.slice(8)})` : `NEW.${this.quote(name)}`} IS NULL THEN ${managed} ELSE ${src} END)`
   }
 }
 

package/node_modules/@cap-js/db-service/lib/cqn4sql.js

@@ -33,6 +33,9 @@ const notSupportedOps = [['>'], ['<'], ['>='], ['<='], ['*'], ['+'], ['-'], ['/'
 
 const allOps = eqOps.concat(eqOps).concat(notEqOps).concat(notSupportedOps)
 
+
+const { depthGuarded, guardEntry } = require('./recursion-guard')
+
 const { pseudos } = require('./infer/pseudos')
 /**
  * Transforms a CDL style query into SQL-Like CQN:
@@ -55,7 +58,17 @@ const { pseudos } = require('./infer/pseudos')
  * @returns {object} transformedQuery the transformed query
  */
 function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
+  // guardEntry bounds subquery nesting and resets the depth budget per top-level call
+  return guardEntry(_cqn4sql)(originalQuery, model, useTechnicalAlias)
+}
+
+function _cqn4sql(originalQuery, model, useTechnicalAlias = true) {
   const getImplicitAlias = str => _getImplicitAlias(str, useTechnicalAlias)
+  // guard xpr and inline/expand-on-struct nesting
+  // eslint-disable-next-line no-func-assign
+  getTransformedTokenStream = depthGuarded(getTransformedTokenStream)
+  // eslint-disable-next-line no-func-assign
+  nestedProjectionOnStructure = depthGuarded(nestedProjectionOnStructure)
   let inferred = typeof originalQuery === 'string' ? cds.parse.cql(originalQuery) : cds.ql.clone(originalQuery)
   const hasCustomJoins =
     originalQuery.SELECT?.from.args && (!originalQuery.joinTree || originalQuery.joinTree.isInitial)
@@ -69,6 +82,9 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
       const { where, having } = transformSearch(searchTerm)
       if (where) inferred.SELECT.where = where
       else if (having) inferred.SELECT.having = having
+      // Defer the ranking ORDER BY to after infer(), where the outer table alias is known and the
+      // deep-search sub-select can be correlated to the outer row (see buildSearchRankOrderBy).
+      defineProperty(inferred, '$searchRank', searchTerm)
     }
   }
   // query modifiers can also be defined in from ref leaf infix filter
@@ -182,7 +198,7 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
   /**
    * If the target entity is annotated with persistence skip and has an underlying db entity,
    * we treat it as a runtime view and transform it into a CTE.
-   * 
+   *
    * @param {object} transformedQuery - The query object to be transformed.
    * @param {string} model - The data model used for inference and transformation.
    */
@@ -198,10 +214,10 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
   }
 
   /**
-   * Recursively call cqn4sql for all nested runtime views to calculate cte and 
+   * Recursively call cqn4sql for all nested runtime views to calculate cte and
    * add it as a with clause to the transformed query.
    * Alias the runtime view with a unique alias and update all references to the runtime view to point to the alias.
-   * 
+   *
    * @param {object} rootDefinition - The root definition of the query. This is used to recursively process nested runtime views.
    * @param {object} transformedQuery - The query object to be transformed.
    * @param {string} model - The data model used for infer and cqn4sql.
@@ -317,9 +333,29 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
 
     // Since all the expressions in the SELECT part of the query have been computed,
     // one can reference aliases of the queries columns in the orderBy clause.
-    if (orderBy) {
-      const transformedOrderBy = getTransformedOrderByGroupBy(orderBy, true)
+    let effectiveOrderBy = orderBy
+    // Rank by $search relevance — only when the score exists (HANA fuzzy, not opted out); else
+    // it would sort by a constant boolean.
+    const ranksSearch =
+      cds.db?.kind === 'hana' && cds.env.hana?.fuzzy !== false && cds.env.hana?.fuzzy?.ranked_search !== false
+    // count queries do not need ranked search
+    const isCountQuery = columns?.length === 1 && columns[0].func === 'count'
+    const searchRank = ranksSearch && !isCountQuery && inferred.$searchRank && buildSearchRankOrderBy(inferred.$searchRank)
+    if (searchRank) {
+      // precedence: user ordering, then rank, then the runtime's implicit key ordering
+      const implicitAt = (orderBy || []).findIndex(o => o.implicit)
+      const at = implicitAt === -1 ? (orderBy?.length ?? 0) : implicitAt
+      effectiveOrderBy = [...(orderBy || [])]
+      effectiveOrderBy.splice(at, 0, searchRank)
+    }
+    if (effectiveOrderBy) {
+      const transformedOrderBy = getTransformedOrderByGroupBy(effectiveOrderBy, true)
       if (transformedOrderBy.length) {
+        // the rank is the only order-by entry that is a correlated sub-select
+        if (searchRank?.$searchRank) {
+          const rank = transformedOrderBy.find(o => o.SELECT)
+          if (rank) correlateSearchRank(rank, transformedFrom.as)
+        }
         transformedQuery.SELECT.orderBy = transformedOrderBy
       }
     }
@@ -383,6 +419,8 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
    */
   function translateAssocsToJoins() {
     let from
+    // guard association-path length
+    const joinForBranch = depthGuarded(_joinForBranch)
     /**
      * remember already seen aliases, do not create a join for them again
      */
@@ -406,7 +444,7 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
     })
     return from.args.length > 1 ? from : from.args[0]
 
-    function joinForBranch(lhs, node) {
+    function _joinForBranch(lhs, node) {
       const nextAssoc = inferred.joinTree.findNextAssoc(node)
       if (!nextAssoc || alreadySeen.has(nextAssoc.$refLink.alias)) return lhs.args.length > 1 ? lhs : lhs.args[0]
 
@@ -643,7 +681,7 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
         if (col.cast) ret.cast = resolveEnumCastType(col.cast)
         return ret
       }
-      return copy(col)
+      return { ...col }
     }
 
     function handleEmptyColumns(columns) {
@@ -995,11 +1033,11 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
             const keyName = k.as || k.ref.join('_')
             const fkName = `${elemName}_${keyName}`  // e.g., 'head_id'
             const fkFullName = `${columnAlias}_${fkName}`  // e.g., 'department_head_id'
-            
+
             // Check if this FK is excluded
             if (exclude.some(e => (e.ref?.at(-1) || e.as || e) === fkName)) continue
             if (exclude.some(e => (e.ref?.at(-1) || e.as || e) === fkFullName)) continue
-            
+
             const flatColumn = {
               ref: [joinAlias, fkName],
               as: fkFullName,
@@ -1017,7 +1055,7 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
             calcElement.as = fullName
           }
           res.push(calcElement)
-        }        
+        }
         else {
           // Scalar element
           const flatColumn = {
@@ -1322,7 +1360,7 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
         else if (col.xpr) transformedColumn = { xpr: getTransformedTokenStream(col.xpr) }
         else if (col.func) transformedColumn = { args: getTransformedFunctionArgs(col.args), func: col.func }
         // val
-        else transformedColumn = copy(col)
+        else transformedColumn = { ...col }
         if (col.sort) transformedColumn.sort = col.sort
         if (col.nulls) transformedColumn.nulls = col.nulls
         res.push(transformedColumn)
@@ -1397,8 +1435,13 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
       if (!exclude.includes(k)) {
         const { index, tableAlias } = inferred.$combinedElements[k][0]
         const element = tableAlias.elements[k]
-        // ignore FK for odata csn (but not for subquery sources where FK is not a separate element) / ignore blobs from wildcard expansion
-        if ((!tableAlias.SELECT && isManagedAssocInFlatMode(element)) || element.type === 'cds.LargeBinary') continue
+        // ignore FK for odata csn (but not for subquery sources where FK is not a separate element) / ignore blobs and vectors from wildcard expansion
+        if (
+          (!tableAlias.SELECT && isManagedAssocInFlatMode(element)) ||
+          element.type === 'cds.LargeBinary' ||
+          element.type === 'cds.Vector'
+        )
+          continue
         // for wildcard on subquery in from, just reference the elements
         if (tableAlias.SELECT && !element.elements && !element.target) {
           wildcardColumns.push(index ? { ref: [index, k] } : { ref: [k] })
@@ -1461,7 +1504,7 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
    *   - `tableAlias` — table alias prepended to the column ref.
    * @param {string[]} [csnPath=[]] - Accumulated CSN element path (used for `_csnPath` metadata on leaf columns).
    * @param {{ exclude?: Array, replace?: Array }} [excludeAndReplace] - Columns to exclude or replace during wildcard expansion.
-   * @param {boolean} [isWildcard=false] - Whether this expansion originates from a wildcard; filters out LargeBinary.
+   * @param {boolean} [isWildcard=false] - Whether this expansion originates from a wildcard; filters out LargeBinary and Vector.
    * @returns {object[]} Flat column(s) for the given element.
    */
   function getFlatColumnsFor(column, names, csnPath = [], excludeAndReplace, isWildcard = false) {
@@ -1474,7 +1517,7 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
     const { $refLinks, flatName, isJoinRelevant } = column
     let firstNonJoinRelevantAssoc, stepAfterAssoc
     let element = $refLinks ? $refLinks[$refLinks.length - 1].definition : column
-    if (isWildcard && element.type === 'cds.LargeBinary') return []
+    if (isWildcard && (element.type === 'cds.LargeBinary' || element.type === 'cds.Vector')) return []
     if (element.on && !element.keys) return [] // unmanaged doesn't make it into columns
     if (element.virtual === true) return []
 
@@ -1812,8 +1855,7 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
           // reject virtual elements in expressions as they will lead to a sql error down the line
           if (lhsDef?.virtual) throw new Error(`Virtual elements are not allowed in expressions`)
 
-          let result = is_regexp(token?.val) ? token : copy(token) // REVISIT: too expensive!
-          // REVISIT: required because we copy the token above and lose the not enumerable "param: false"
+          let result = typeof token !== 'object' || is_regexp(token?.val) ? token : { ...token }
           if (typeof token === 'object' && 'val' in token && 'param' in token) Object.defineProperty(result, 'param', { value: token.param })
           if (token.ref) {
             const { definition } = token.$refLinks.at(-1)
@@ -1830,7 +1872,6 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
                 const stepToFind = token.ref[1]?.id || token.ref[1]
                 const outerAlias = outerQuery.$combinedElements?.[stepToFind]?.[0].index
                 if (outerAlias) {
-                  let result = copy(token)
                   result.ref = [outerAlias, token.flatName]
                   transformedTokenStream.push(result)
                   continue
@@ -2016,7 +2057,7 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
    */
   function getTransformedFrom(from, existingWhere = []) {
     const transformedWhere = []
-    let transformedFrom = copy(from) // REVISIT: too expensive!
+    let transformedFrom = { ...from }
     if (from.$refLinks) defineProperty(transformedFrom, '$refLinks', [...from.$refLinks])
     if (from.args) {
       transformedFrom.args = []
@@ -2579,6 +2620,65 @@ function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
     return { xpr: [matchColumns.length === 1 ? matchColumns[0] : { list: matchColumns }, 'in', subquery] }
   }
 
+  /**
+   * Builds the ORDER BY entry ranking rows by $search relevance, sorted desc.
+   *
+   * Flat search: the score is on the outer row.
+   * Deep search: the score lives in a semi-join, so emit a correlated scalar sub-select
+   *   (SELECT search(…, true) FROM <same source> WHERE innerKey = <outerAlias>.key) DESC.
+   * Key comparisons are seeded unqualified (infer() binds them to the sub-select's own source);
+   * correlateSearchRank redirects the rhs to the outer alias afterwards.
+   *
+   * @param {object} searchTerm the search term as returned by getSearch (func or xpr shape)
+   * @returns {object|null} an orderBy entry, or null if there is nothing to rank by
+   */
+  function buildSearchRankOrderBy(searchTerm) {
+    if (searchTerm.func) return { func: searchTerm.func, args: [...searchTerm.args, { val: true }], sort: 'desc' }
+    if (!searchTerm.xpr) return null
+
+    const searchSelect = searchTerm.xpr[2]
+    const searchFunc = searchSelect.SELECT.where[0]
+    const innerKeys = searchSelect.SELECT.columns // unqualified pk refs, e.g. [{ ref: ['ID'] }]
+
+    const where = []
+    for (let i = 0; i < innerKeys.length; i++) {
+      if (i) where.push('and')
+      // seeded unqualified on both sides; correlateSearchRank redirects the rhs to the outer row
+      where.push({ ref: [...innerKeys[i].ref] }, '=', { ref: [...innerKeys[i].ref] })
+    }
+
+    const entry = {
+      __proto__: SELECT.from(searchSelect.SELECT.from)
+        // the correlated outer row fans out to many child rows -> MAX makes it a single score
+        .columns({ func: 'max', args: [{ func: searchFunc.func, args: [...searchFunc.args, { val: true }] }] })
+        .where(where),
+      sort: 'desc',
+    }
+    defineProperty(entry, '$searchRank', true)
+    return entry
+  }
+
+  /**
+   * Correlates the (transformed) deep-search ranking sub-select to the outer row.
+   *
+   * buildSearchRankOrderBy seeds its WHERE as `ref = ref` comparisons on the sub-select's own
+   * alias; this rewrites each rhs to `<outerAlias>.<key>`. Driven off the `=` operator (not a
+   * fixed stride) so it holds for any key count.
+   *
+   * @param {object} entry the transformed orderBy entry produced from a `$searchRank` sub-select
+   * @param {string} outerAlias the final table alias of the outer query source
+   */
+  function correlateSearchRank(entry, outerAlias) {
+    const where = entry.SELECT.where
+    for (let i = 1; i < where.length; i++) {
+      // seeded comparisons are exactly `<ref> = <ref>`; rewrite the rhs ref to the outer row
+      if (where[i] === '=' && where[i - 1]?.ref && where[i + 1]?.ref) {
+        const rhs = where[i + 1]
+        rhs.ref = [outerAlias, ...rhs.ref.slice(1)]
+      }
+    }
+  }
+
   /**
    * Calculates the name of the source which can be used to address the given node.
    *