@sap/cds 7.5.2 → 7.6.1

package/libx/_runtime/common/utils/generateOnCond.js

@@ -29,38 +29,63 @@ const _adaptRefs = (onCond, path, { select, join }) => {
   return onCond.map(_adaptEl)
 }
 
-const _args = (csnElement, path, aliases) => {
-  const onCond = csnElement.on
-  if (!onCond || onCond.length === 0) return []
-  if (onCond.length < 3 && !onCond[0]?.xpr) return onCond
-  if (!csnElement._isSelfManaged) return _adaptRefs(onCond, path, aliases)
+const replace$selfAndAliasOnCOnd = (xpr, csnElement, aliases, path) => {
+  const selfIndex = xpr.findIndex(({ ref }) => ref?.[0] === '$self')
+  if (selfIndex != -1) {
+    let backLinkIndex
+    if (xpr[selfIndex + 1] && xpr[selfIndex + 1] === '=') backLinkIndex = selfIndex + 2
+    if (xpr[selfIndex - 1] && xpr[selfIndex - 1] === '=') backLinkIndex = selfIndex - 2
+    if (backLinkIndex != null) {
+      const ref = xpr[backLinkIndex].ref
+      const backlinkName = ref[ref.length - 1]
+      const mutOnCond = _newOnConditions(csnElement._backlink, [backlinkName], {
+        select: aliases.join,
+        join: aliases.select
+      })
+
+      xpr.splice(Math.min(backLinkIndex, selfIndex), 3, ...mutOnCond)
+    }
+  }
 
-  // revert join and select aliases because of backlink
-  const mutOnCond = _newOnConditions(csnElement._backlink, [csnElement._backlink.name], {
-    select: aliases.join,
-    join: aliases.select
-  })
+  for (let i = 0; i < xpr.length; i++) {
+    const element = xpr[i]
+    if (element.xpr) {
+      replace$selfAndAliasOnCOnd(element.xpr, csnElement, aliases, path)
+      continue
+    }
 
-  if (onCond.some(e => e === 'and')) {
-    // managed with ON-conditions must contain `$self`, which we replace with `mutOnCond`
-    const onCondWithoutSelf = _adaptRefs(_onCondWithout$self(onCond), path, aliases)
-    mutOnCond.push('and', ...onCondWithoutSelf)
-  }
+    if (element.ref) {
+      if (element.ref[0] === path.join('_') && element.ref[1]) {
+        element.ref = _toRef(aliases.select, element.ref.slice(1)).ref
+        continue
+      }
+
+      // no alias for special $user of canonical localized association
+      if (element.ref[0] === '$user' && path[0] === 'localized') {
+        element.ref = _toRef(undefined, element.ref.slice(0)).ref
+        continue
+      }
+
+      if (element.ref[0] === aliases.join || element.ref[0] === aliases.select) {
+        // nothing todo here, as already right alias
+        continue
+      }
 
-  return mutOnCond
+      element.ref = _toRef(aliases.join, element.ref.slice(0)).ref
+    }
+  }
 }
 
-const _isSelfRef = e => e && e.ref && e.ref[0] === '$self'
+const _args = (csnElement, path, aliases) => {
+  const onCond = csnElement.on
+  if (!onCond || onCond.length === 0) return []
+  if (onCond.length < 3 && !onCond[0]?.xpr) return onCond
+  if (!csnElement._isSelfManaged) return _adaptRefs(onCond, path, aliases)
 
-const _onCondWithout$self = onCond => {
-  const onCondWithoutSelf = [...onCond]
-  const selfIndex = onCondWithoutSelf.findIndex((e, i, on) => {
-    if (e === 'and') return _isSelfRef(on[i + 1]) || _isSelfRef(on[i + 3])
-    return on[i + 1] === '=' && (_isSelfRef(e) || _isSelfRef(on[i + 2]))
-  })
+  const onCondCopy = JSON.parse(JSON.stringify(onCond))
+  replace$selfAndAliasOnCOnd(onCondCopy, csnElement, aliases, path)
 
-  onCondWithoutSelf.splice(selfIndex, 4)
-  return onCondWithoutSelf
+  return onCondCopy
 }
 
 // this is only for 2one managed w/o on-conditions, i.e. no static values are possible

package/libx/_runtime/common/utils/resolveView.js

@@ -237,28 +237,13 @@ const _newInsertColumns = (columns = [], transition) => {
 const _newWhereRef = (newWhereElement, transition, alias, tableName, isSubSelect) => {
   const newRef = Array.isArray(newWhereElement.ref) ? [...newWhereElement.ref] : [newWhereElement.ref]
 
-  if (newRef[0] === alias) {
+  if (newRef.length > 1 && newRef[0] === alias) {
     const mapped = transition.mapping.get(newRef[1])
-    if (mapped) {
-      const tableAlias =
-        transition.queryTarget.query?.SELECT?.from.as ??
-        transition.queryTarget.query?.SELECT?.from.ref.at(-1).split('.').pop()
-      const newMapped = []
-
-      if (tableAlias && mapped.ref[0] === tableAlias) {
-        // remove table alias from mapped array
-        newMapped.push(...mapped.ref.slice(1))
-      } else {
-        newMapped.push(...mapped.ref)
-      }
-
-      // we assume it's a foreign key or single element
-      newRef[1] = newMapped.join('_')
-    }
-  } else if (newRef[0] === tableName) {
+    if (mapped) newRef[1] = mapped.ref.join('_')
+  } else if (newRef.length > 1 && newRef[0] === tableName) {
     newRef[0] = transition.target.name
     const mapped = transition.mapping.get(newRef[1])
-    if (mapped) newRef[1] = mapped.ref[0]
+    if (mapped) newRef[1] = mapped.ref.join('_')
   } else {
     const mapped = transition.mapping.get(newRef[0])
     if (isSubSelect && mapped && newRef.length === 1) {
@@ -425,28 +410,6 @@ const _newSelect = (query, transitions, service) => {
   return newSelect
 }
 
-const _newStream = (query, transitions) => {
-  const targetTransition = transitions[transitions.length - 1]
-  const targetName = targetTransition.target.name
-  const newStream = Object.create(query.STREAM)
-  if (newStream.into) {
-    const refObject = newStream.into.ref ? newStream.into : { ref: [query.STREAM.into] }
-    newStream.into = {
-      ...refObject,
-      ref: _rewriteQueryPath(refObject, transitions)
-    }
-    if (!query.STREAM.into.ref) newStream.into = newStream.into.ref[0] // leave as string
-  } else {
-    newStream.into = targetName
-  }
-  if (newStream.column) newStream.column = _resolveColumn(newStream.column, targetTransition)
-  Object.defineProperty(newStream, '_transitions', {
-    enumerable: false,
-    value: transitions
-  })
-  return newStream
-}
-
 const _newInsert = (query, transitions, service) => {
   const targetTransition = transitions[transitions.length - 1]
   const targetName = targetTransition.target.name
@@ -725,8 +688,7 @@ const _newQuery = (query, event, model, service) => {
     INSERT: ['into', _newInsert],
     UPSERT: ['into', _newUpsert],
     UPDATE: ['entity', _newUpdate],
-    DELETE: ['from', _newDelete],
-    STREAM: ['into', _newStream]
+    DELETE: ['from', _newDelete]
   }[event]
   const newQuery = Object.create(query)
   const transitions = _entityTransitionsForTarget(query[event][_prop], model, service)
@@ -747,7 +709,6 @@ const resolveView = (query, model, service) => {
   else if (query.UPSERT) _event = 'UPSERT'
   else if (query.UPDATE) _event = 'UPDATE'
   else if (query.DELETE) _event = 'DELETE'
-  else if (query.STREAM) _event = 'STREAM'
 
   const newQuery = _newQuery(query, _event, model, service)
 

package/libx/_runtime/common/utils/rewriteAsterisks.js

@@ -36,9 +36,13 @@ const _resolveTarget = (ref, target) => {
       // in case there is an alias, try with the next entry
       return _resolveTarget(ref.slice(1), target)
     }
-  } else {
-    return target.elements[ref[0].id || ref[0]]._target
   }
+
+  const _ref = ref[0].id || ref[0]
+  const element = target.elements[_ref]
+  if (element) return element._target
+
+  throw cds.error(`Navigation property '${_ref}' is not defined in type '${target.name}'`, { code: 400 })
 }
 
 const rewriteExpandAsterisk = (columns, target) => {
@@ -64,6 +68,8 @@ const rewriteExpandAsterisk = (columns, target) => {
   }
 }
 
+const _isLargeBinary = (col, target) => target.elements[col.ref[col.ref.length - 1]]?.type === 'cds.LargeBinary'
+
 const _rewriteAsterisk = (columns, target, _4db, isRoot) => {
   const asteriskColumnIndex = columns.findIndex(col => isAsteriskColumn(col))
   if (asteriskColumnIndex > -1) {
@@ -72,7 +78,12 @@ const _rewriteAsterisk = (columns, target, _4db, isRoot) => {
       1,
       ...getColumns(target, { _4db })
         .map(c => ({ ref: [c.name] }))
-        .filter(c => !columns.find(isDuplicate(c)) && (isRoot || c.ref[0] !== 'DraftAdministrativeData_DraftUUID'))
+        .filter(
+          c =>
+            !columns.find(isDuplicate(c)) &&
+            (!_4db || cds.env.features.stream_compat || !_isLargeBinary(c, target)) &&
+            (isRoot || c.ref[0] !== 'DraftAdministrativeData_DraftUUID')
+        )
     )
   }
 }
@@ -139,7 +150,9 @@ const rewriteAsterisks = (query, model, options) => {
         const target = _targetOfQueryIfNotDraft(query, model)
         if (!target) return
 
-        query.SELECT.columns = getColumns(target, { _4db }).map(col => ({ ref: [col.name] }))
+        query.SELECT.columns = getColumns(target, { _4db })
+          .map(col => ({ ref: [col.name] }))
+          .filter(col => !_4db || cds.env.features.stream_compat || !_isLargeBinary(col, target))
         if (_4db && target._isDraftEnabled && !cds.env.fiori.lean_draft)
           query.SELECT.columns.push(..._cqlDraftColumns(target))
       }

package/libx/_runtime/common/utils/stream.js

@@ -12,9 +12,7 @@ const { isPathToDraft } = require('./cqn')
 // eslint-disable-next-line complexity
 const _getStreamProperties = (req, query, model) => {
   // new odata parser sets streaming property in SELECT.from
-  const ref = query.SELECT
-    ? (query.SELECT.columns && query.SELECT.columns[0].ref) || query.SELECT.from.ref
-    : [query.STREAM.column]
+  const ref = (query.SELECT.columns && query.SELECT.columns[0].ref) || query.SELECT.from.ref
   const propertyName = ref[ref.length - 1]
   let mediaTypeProperty
   for (let key in req.target.elements) {
@@ -25,10 +23,13 @@ const _getStreamProperties = (req, query, model) => {
     }
   }
 
+  // REVISIT: workaround for read after write
+  // if (!mediaTypeProperty) return {}
+
   let contentType, contentDispositionFilename
   const columns = []
   if (typeof mediaTypeProperty['@Core.MediaType'] === 'object') {
-    let contentTypeProperty = mediaTypeProperty['@Core.MediaType']['=']
+    let contentTypeProperty = mediaTypeProperty['@Core.MediaType']['='].replaceAll(/\./g, '_')
     if (!req.target.elements[contentTypeProperty]) {
       LOG._warn &&
         LOG.warn(
@@ -48,7 +49,10 @@ const _getStreamProperties = (req, query, model) => {
   }
   if (mediaTypeProperty['@Core.ContentDisposition.Filename']) {
     if (typeof mediaTypeProperty['@Core.ContentDisposition.Filename'] === 'object') {
-      let contentDispositionProperty = mediaTypeProperty['@Core.ContentDisposition.Filename']['=']
+      let contentDispositionProperty = mediaTypeProperty['@Core.ContentDisposition.Filename']['='].replaceAll(
+        /\./g,
+        '_'
+      )
       if (!req.target.elements[contentDispositionProperty]) {
         LOG._warn &&
           LOG.warn(
@@ -72,12 +76,11 @@ const _getStreamProperties = (req, query, model) => {
 
   if (columns.length && cds.db && !req.target._hasPersistenceSkip) {
     // used cloned path
-    const ref = query.SELECT ? query.SELECT.from.ref : query.STREAM.from.ref
-    const as = query.SELECT ? query.SELECT.from.as : query.STREAM.from.as
-    let select = SELECT.one.from({ ref: deepCopyArray(ref), as }).columns(columns)
-    const where = query.SELECT ? query.SELECT.where : query.STREAM.where
-    if (where?.length) select.SELECT.where = where
-    if (!(isNewStream() || cds.env.fiori.lean_draft)) {
+    let select = SELECT.one
+      .from({ ref: deepCopyArray(query.SELECT.from.ref), as: query.SELECT.from.as })
+      .columns(columns)
+    if (query.SELECT.where?.length) select.SELECT.where = query.SELECT.where
+    if (!cds.env.fiori.lean_draft) {
       const draft = req.target._isDraftEnabled && isPathToDraft(select.SELECT.from.ref, model)
       if (draft) {
         select = cqn2cqn4sql(select, model)
@@ -99,7 +102,6 @@ const _getStreamProperties = (req, query, model) => {
 }
 
 const enhanceStreamResult = async (req, query, result, model) => {
-  if (!result) return
   if (result.$mediaContentType || result.$mediaContentDispositionFilename || result.$mediaContentDispositionType) return
 
   const { contentType, contentDispositionFilename, contentDispositionType } = await _getStreamProperties(
@@ -124,6 +126,7 @@ const processFn = ({ row, key }) => {
 }
 
 function transformRedirectProperties(req, service, result) {
+  if (!result) return
   if (!Array.isArray(result)) result = [result]
   if (result.length === 0) return
 
@@ -135,6 +138,4 @@ function transformRedirectProperties(req, service, result) {
   }
 }
 
-const isNewStream = () => cds.env.features.new_stream && (!cds.db || !!cds.db.stream('foo').STREAM)
-
-module.exports = { isNewStream, enhanceStreamResult, transformRedirectProperties }
+module.exports = { enhanceStreamResult, transformRedirectProperties }

package/libx/_runtime/common/utils/streamProp.js

@@ -1,10 +1,12 @@
+const cds = require('../../cds')
 const { ensureNoDraftsSuffix, ensureUnlocalized } = require('../../fiori/utils/handler')
 const { isDuplicate } = require('./rewriteAsterisks')
 
 const _addColumn = (name, type, columns) => {
   if (typeof type === 'object') {
+    let mType = type['='].replaceAll(/\./g, '_')
     const ref = {
-      ref: [type['=']],
+      ref: [mType],
       as: `${name}@odata.mediaContentType`
     }
     if (!columns.find(isDuplicate(ref))) columns.push(ref)
@@ -14,39 +16,40 @@ const _addColumn = (name, type, columns) => {
   }
 }
 
-const _changeStreamProperties = (target, columns, model) => {
+const _addColumns = (target, columns) => {
+  for (const k in target.elements) {
+    const el = target.elements[k]
+    if (el['@Core.MediaType']) {
+      _addColumn(el.name, el['@Core.MediaType'], columns)
+    }
+  }
+}
+
+const handleStreamProperties = (target, columns, model) => {
+  if (!target || !model || !columns) return
+
   let index = columns.length
   while (index--) {
     const col = columns[index]
     const name = col.ref && col.ref[col.ref.length - 1]
     const element = name && target.elements[name]
-    const type = element && element['@Core.MediaType']
+    const type = element && element.type
+    const mediaType = element && element['@Core.MediaType']
 
     if (col === '*') {
-      for (const k in target.elements) {
-        const el = target.elements[k]
-        if (el['@Core.MediaType']) {
-          const type = el['@Core.MediaType']
-          _addColumn(el.name, type, columns)
-        }
+      _addColumns(target, columns)
+    } else if (col.ref && type === 'cds.LargeBinary') {
+      if (mediaType) {
+        _addColumn(name, mediaType, columns)
+      }
+      if ((mediaType || !cds.env.features.stream_compat) && !element['@Core.IsURL']) {
+        columns.splice(index, 1)
       }
-    } else if (col.ref && type) {
-      _addColumn(name, type, columns)
-      if (!element['@Core.IsURL']) columns.splice(index, 1)
     } else if (col.expand && col.ref) {
       const tgt = target.elements[col.ref] && target.elements[col.ref].target
-      tgt && _changeStreamProperties(model.definitions[ensureUnlocalized(ensureNoDraftsSuffix(tgt))], col.expand, model)
+      tgt && handleStreamProperties(model.definitions[ensureUnlocalized(ensureNoDraftsSuffix(tgt))], col.expand, model)
     }
   }
 }
 
-const handleStreamProperties = (target, select, model, _4odata) => {
-  const columns = select.SELECT?.columns
-  if (!columns || !target || !model) return
-  if (!_4odata && !select.SELECT._4odata) return
-  if (select._streaming) return
-
-  _changeStreamProperties(target, columns, model)
-}
-
 module.exports = { handleStreamProperties }

package/libx/_runtime/db/Service.js

@@ -73,22 +73,42 @@ class DatabaseService extends cds.Service {
    */
   _runStream(streamQuery, result) {
     this.run(streamQuery).then(stream => {
-      if (!stream) {
-        result.push(null)
+      if (cds.env.features.stream_compat) {
+        if (!stream || !stream.value) {
+          result.push(null)
+        } else {
+          stream.value.pipe(result)
+        }
       } else {
-        stream.value.pipe(result)
+        const col = streamQuery.SELECT.columns[0].ref[0]
+        if (!stream || !stream[col]) {
+          result.push(null)
+        } else {
+          stream[col].pipe(result)
+        }
       }
     })
   }
 
   stream(query) {
+    cds._logDeprecation('stream method is deprecated and will be removed in upcoming releases!')
     // aynchronous API: cds.stream(query)
     if (typeof query === 'object') {
       // eslint-disable-next-line no-async-promise-executor
       return new Promise(async (resolve, reject) => {
         try {
-          const res = await this.run(Object.assign(query, { _streaming: true }))
-          resolve((res && res.value) || res)
+          if (cds.env.features.stream_compat) {
+            const res = await this.run(Object.assign(query, { _streaming: true }))
+            resolve(res && res.value)
+          } else {
+            const res = await this.run(query)
+            // rely on query returning correct column (as documented for srv.stream(query))
+            if (Array.isArray(res)) {
+              resolve(res.length ? Object.values(res[0])[0] : undefined)
+            } else {
+              resolve(res && Object.values(res)[0])
+            }
+          }
         } catch (e) {
           reject(e)
         }
@@ -98,13 +118,12 @@ class DatabaseService extends cds.Service {
     // synchronous API: cds.stream('column').from(entity).where(...)
     return {
       from: (...args) => {
-        const streamQuery = SELECT.from(...args)
+        const streamQuery = SELECT.one.from(...args)
         if (query && (!streamQuery.SELECT.columns || streamQuery.SELECT.columns.length !== 0)) {
           streamQuery.columns([query])
         }
 
-        delete streamQuery.SELECT.one
-        streamQuery._streaming = true
+        if (cds.env.features.stream_compat) streamQuery._streaming = true
 
         const result = new Transform({
           transform(chunk, encoding, callback) {

package/libx/_runtime/db/generic/input.js

@@ -102,7 +102,12 @@ const _processCategory = (req, category, { row, key, element }) => {
   }
 
   // generate UUIDs
-  if (category === 'uuid' && !val && req.event === 'CREATE') {
+  if (
+    category === 'uuid' &&
+    !val &&
+    req.event === 'CREATE' &&
+    !element.parent.elements[element._foreignKey4]?._isAssociationStrict
+  ) {
     row[key] = cds.utils.uuid()
   }
 }

package/libx/_runtime/db/generic/rewrite.js

@@ -1,3 +1,4 @@
+const cds = require('../../cds')
 const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
 const { generateAliases } = require('../utils/generateAliases')
 const { restoreLink } = require('../../common/utils/resolveView')
@@ -25,7 +26,7 @@ function handler(req) {
     return
   }
 
-  const streaming = req.query._streaming
+  const streaming = cds.env.features.stream_compat && req.query._streaming
 
   // for restore link to req.data
   const linked = _isLinked(req)
@@ -37,7 +38,7 @@ function handler(req) {
   // restore link to req.data
   if (linked) restoreLink(req)
 
-  if (streaming) req.query._streaming = streaming
+  if (cds.env.features.stream_compat && streaming) req.query._streaming = streaming
   generateAliases(req.query)
 }
 

package/libx/_runtime/db/query/read.js

@@ -1,3 +1,4 @@
+const cds = require('../../cds')
 const normalizeTimestamp = require('../../common/utils/normalizeTimestamp')
 const { deepCopyObject } = require('../../common/utils/copy')
 const getError = require('../../common/error')
@@ -37,16 +38,21 @@ const countValue = countResults => {
   if (countResult.$count != null) return countResult.$count
 }
 
-const read = (executeSelectCQN, executeStreamCQN) => (model, dbc, query, req) => {
+const read = (executeSelectCQN, executeStreamCQN, convertStreams) => (model, dbc, query, req) => {
   const { user, locale, timestamp } = req
   const isoTs = normalizeTimestamp(timestamp)
 
-  if (query._streaming) {
-    if (!query.SELECT || (query.SELECT && !query.SELECT.columns)) {
+  if (cds.env.features.stream_compat && query._streaming) {
+    if (!query.SELECT || !query.SELECT.columns) {
       throw getError(500, 'Invalid SELECT statement for streaming')
     }
 
-    return executeStreamCQN(model, dbc, query, user, locale, isoTs)
+    return executeStreamCQN({ model, dbc, query, user, locale, isoTs })
+  }
+
+  // REVISIT: streaming from OData - to be generalized to all streaming properties
+  if (query.SELECT?.columns?.find(col => col.as === '$mediaContentType')) {
+    return executeStreamCQN({ model, dbc, query, user, locale, isoTs })
   }
 
   // needed in case of expand
@@ -72,7 +78,11 @@ const read = (executeSelectCQN, executeStreamCQN) => (model, dbc, query, req) =>
     )
   }
 
-  return executeSelectCQN(model, dbc, query, user, locale, isoTs)
+  return executeSelectCQN(model, dbc, query, user, locale, isoTs).then(result => {
+    if (!cds.env.features.stream_compat) convertStreams(query.SELECT.columns, query.target, result, query.SELECT.one)
+
+    return result
+  })
 }
 
 module.exports = read

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

@@ -1,17 +1,6 @@
-const cds = require('../../cds')
-
 const BaseBuilder = require('./BaseBuilder')
 const { flattenStructuredWhereHaving } = require('../../common/utils/structured')
 
-const SQLITE_DATETIME_FUNCTIONS = new Set(['year', 'month', 'day', 'second', 'hour', 'minute'])
-const HANA_DATETIME_FUNCTIONS = new Set(['year', 'month', 'dayofmonth', 'second', 'hour', 'minute'])
-const OPERATORS = new Set(['=', '!=', '<>', '<', '>', '<=', '>='])
-
-function _fillAfterDot(val) {
-  const [beforeDot, afterDot = ''] = val.split('.')
-  return `${beforeDot}.${afterDot.padEnd(3, '0')}`
-}
-
 function _valButNoBuffer(arg) {
   return arg && arg.val && typeof arg.val === 'object' && !(arg.val instanceof Buffer)
 }

package/libx/_runtime/db/utils/columns.js

@@ -21,6 +21,7 @@ const getColumns = (entity, { _4db, onlyKeys } = { _4db: true, onlyKeys: false }
   const elements = lean_draft ? entity.elements : Object.getPrototypeOf(entity.elements) || entity.elements
   for (const elementName in elements) {
     const element = elements[elementName]
+    if (element['@cds.api.ignore']) continue
     if (onlyKeys && !element.key) continue
     if (element.isAssociation) continue
     if (!lean_draft && _4db && entity._isDraftEnabled && elementName in DRAFT_COLUMNS_MAP) continue

package/libx/_runtime/db/utils/stream.js

@@ -0,0 +1,41 @@
+const { Readable } = require('stream')
+
+const _stream = val => {
+  if (val === null) return null
+  return new Readable({
+    read(size) {
+      if (val.length === 0) return this.push(null)
+      const chunk = val.slice(0, size)
+      val = val.slice(size)
+      this.push(chunk)
+    }
+  })
+}
+
+const convertStream = (columns, target, result, one) => {
+  if (!result || !columns || !target) return
+  if (!Array.isArray(result)) result = [result]
+  if (!result.length) return
+
+  for (let col of columns) {
+    let name = col.ref?.[col.ref.length - 1] || (typeof col === 'string' && col)
+    const element = target.elements?.[name]
+    if (!element) continue
+    name = col.as || name
+    if (element.isAssociation) {
+      if (one) convertStream(col.expand, element._target, result[0][name], false)
+      else
+        result.forEach(row => {
+          convertStream(col.expand, element._target, row[name], false)
+        })
+    } else if (element.type === 'cds.LargeBinary') {
+      if (one) result[0][name] = _stream(result[0][name])
+      else
+        result.forEach(row => {
+          row[name] = _stream(row[name])
+        })
+    }
+  }
+}
+
+module.exports = { convertStream }

package/libx/_runtime/fiori/generic/read.js

@@ -1187,6 +1187,7 @@ const _getOriginalColumns = req => {
   return originalColumns
 }
 
+// REVISIT: remove after stream_compat is removed
 const _handlerStreaming = async (req, query) => {
   adaptStreamCQN(query)
   query._streaming = true
@@ -1289,7 +1290,7 @@ const fioriGenericRead = async function (req, next) {
   // Clone draft restrictions to the cloned query.
   reqClone.query._draftRestrictions = query._draftRestrictions
 
-  if (query._streaming) return _handlerStreaming(req, reqClone.query)
+  if (cds.env.features.stream_compat && query._streaming) return _handlerStreaming(req, reqClone.query)
 
   let cqnScenario
 

package/libx/_runtime/fiori/generic/readOverDraft.js

@@ -120,7 +120,7 @@ const _readOverDraftHandler = async function (req, next) {
   // REVISIT DRAFT HANDLING: cqn2cqn4sql must not be called here
   const sqlQuery = cqn2cqn4sql(req.query, this.model, { _4db: req.target._isDraftEnabled, _4fiori: true })
 
-  if (req.query._streaming) {
+  if (cds.env.features.stream_compat && req.query._streaming) {
     sqlQuery._streaming = true
   }