@sap/cds-compiler 2.10.4 → 2.11.0

package/lib/json/from-csn.js

@@ -773,12 +773,8 @@ function arrayOf( fn, filter = undefined ) {
     } );
     const minLength = spec.minLength || 0;
     if (minLength > val.length) {
-      error( 'syntax-csn-expected-length', location(true),
-             { prop: spec.prop, n: minLength, '#': minLength === 1 ? 'one' : 'std' },
-             {
-               std: 'Expected array in $(PROP) to have at least $(N) items',
-               one: 'Expected array in $(PROP) to have at least one item',
-             } );
+      message( 'syntax-csn-expected-length', location(true),
+               { prop: spec.prop, n: minLength, '#': minLength === 1 ? 'one' : 'std' });
     }
     if (val.length)
       ++virtualLine;          // [] in one JSON line
@@ -913,7 +909,7 @@ function definition( def, spec, xsn, csn, name ) {
       ++virtualLine;
     }
   }
-  if (!r.name && name) {
+  if (!r.name && name != null) {
     r.name = { id: name, location: r.location };
     if (prop === 'columns' || prop === 'keys' || prop === 'foreignKeys')
       r.name.$inferred = 'as';
@@ -1002,13 +998,13 @@ function selectItem( def, spec, xsn, csn ) {
   return definition( def, spec, xsn, csn, null ); // definer sets name
 }
 
-function returnsDefinition( def, spec, xsn, csn, name ) {
+function returnsDefinition( def, spec, xsn, csn ) {
   // TODO: be stricter in what is allowed inside returns
   if (!inExtensions)
-    return definition( def, spec, xsn, csn, name );
+    return definition( def, spec, xsn, csn, '' );
   // for the moment, flatten elements in returns in an annotate
   // TODO: bigger Core Compiler changes would have to be done otherwise
-  xsn.elements = definition( def, spec, xsn, csn, name ).elements;
+  xsn.elements = definition( def, spec, xsn, csn, '' ).elements;
   xsn.$syntax = 'returns';
   return undefined;
 }
@@ -1271,6 +1267,10 @@ function func( val, spec, xsn ) {
 
 function xpr( exprs, spec, xsn, csn ) {
   if (csn.func) {
+    if (!exprs.length) {
+      message( 'syntax-csn-expected-length', location(true),
+               { prop: 'xpr', otherprop: 'func', '#': 'suffix' });
+    }
     xsn.suffix = exprArgs( exprs, spec );
   }
   else {

package/lib/json/to-csn.js

@@ -33,12 +33,15 @@ let projectionAsQuery = false;
 let withLocations = false;
 let dictionaryPrototype = null;
 
+// Properties for dictionaries, set in compileX() and TODO: parseX(), must be
+// stored with symbols as keys, as we do not want to disallow any key name:
+const $inferred = Symbol.for('cds.$inferred');
+
 // IMPORTANT: the order of these properties determine the order of properties
 // in the resulting CSN !!!  Also check const `csnPropertyNames`.
 const transformers = {
   // early and modifiers (without null / not null) ---------------------------
   kind,
-  _outer: ( _, csn, node ) => addOrigin( csn, node ),
   id: n => n,                   // in path item
   doc: value,
   '@': value,
@@ -67,7 +70,7 @@ const transformers = {
   targetAspect,
   target,
   foreignKeys,
-  enum: insertOrderDict,
+  enum: enumDict,
   items,
   includes: arrayOf( artifactRef ), // also entities
   // late expressions / query properties -------------------------------------
@@ -199,6 +202,15 @@ const operators = {
   partitionBy: exprs => [
     'partition', 'by', ...exprs[0].concat( ...exprs.slice(1).map( e => [ ',', ...e ] ) ),
   ],
+  rows: exprs => [
+    'rows', ...exprs[0].concat( ...exprs.slice(1).map( e => [ ',', ...e ] ) ),
+  ],
+  preceding: postfix( [ 'preceding' ] ),
+  unboundedPreceding: [ 'unbounded', 'preceding' ],
+  currentRow: [ 'current', 'row' ],
+  unboundedFollowing: [ 'unbounded', 'following' ],
+  following: postfix( [ 'following' ] ),
+  frameBetween: exprs => [ 'between', ...exprs[0], 'and', ...exprs[1] ],
   // xpr: (exprs) => [].concat( ...exprs ), see below - handled extra
 };
 
@@ -622,7 +634,7 @@ function target( val, _csn, node ) {
 }
 
 function items( obj, csn, node ) {
-  if (!keepElements( node ))
+  if (!keepElements( node, obj ))
     return undefined;
   return standard( obj );   // no 'elements' with inferred elements with gensrc
 }
@@ -637,6 +649,18 @@ function elements( dict, csn, node ) {
   return insertOrderDict( dict );
 }
 
+function enumDict( dict, csn, node ) {
+  if (gensrcFlavor && dict[$inferred] ||
+      !keepElements( node ))
+    // no 'elements' with SELECT or inferred elements with gensrc;
+    // hidden or visible 'elements' will be set in query()
+    return undefined;
+  if (universalCsn && node.type && !node.type.$inferred && node.$expand === 'annotate')
+    // derived type of enum type with individual annotations: also set $origin
+    csn.$origin = originRef( node.type._artifact );
+  return insertOrderDict( dict );
+}
+
 function enumerableQueryElements( select ) {
   if (!universalCsn || select === select._main._leadingQuery)
     return false;
@@ -647,13 +671,24 @@ function enumerableQueryElements( select ) {
 }
 
 // Should we render the elements?  (and items?)
-function keepElements( node ) {
+function keepElements( node, line ) {
   if (universalCsn)
     // $expand = null/undefined: not elements not via expansion
     // $expand = 'target'/'annotate': with redirections / individual annotations
     return node.$expand !== 'origin';
   if (!node.type || node.kind === 'type')
     return true;
+  // keep many SimpleType/Entity
+  if (line) {
+    if (!node.type)
+      return true;
+    const array = node.type._artifact; // see function items() in propagator.js
+    const ltype = line.type && line.type._artifact;
+    if (!array ||     // reference errors
+        array._main && !line.elements && !line.enum && !line.items && !line.notNull &&
+        (!ltype || !ltype._main)) // many Foo:bar -> not SimpleType
+      return true;
+  }
   // even if expanded elements have no new target or direct annotation,
   // they might have got one via propagation – any new target/annos during their
   // way from the original structure type definition to the current usage
@@ -801,44 +836,143 @@ function definition( art, _csn, _node, prop ) {
     delete c.elements;
     c.returns = { elements: elems };
   }
+  if (kind && kind !== 'key')
+    addOrigin( c, art, art._origin );
   return c;
 }
 
-function addOrigin( csn, xsn ) {
-  if (!universalCsn)
-    return csn;
+// create $origin specification for `includes` of `art`
+function includesOrigin( includes, art ) {
+  const $origin = originRef( includes[0]._artifact );
+  if (includes.length === 1)
+    return $origin;
+  const result = { $origin };
+  for (const incl of includes.slice(1)) {
+    const aspect = incl._artifact;
+    for (const prop in aspect) {
+      if (prop.charAt(0) === '@' && (!art[prop] || art[prop].$inferred)) {
+        const anno = aspect[prop];
+        if (anno.val !== null)
+          // matererialize non-null annos (whether direct or inherited)
+          result[prop] = value( Object.create( anno, { $inferred: { value: null } } ) );
+      }
+    }
+  }
+  return (Object.keys( result ).length === 1) ? $origin : result;
+}
+
+function addOrigin( csn, xsn, origin ) {
+  if (!universalCsn || hasExplicitProp( xsn.type ))
+    return;
   if (xsn._from) {
-    csn.$origin = originRef( xsn._from[0]._origin );
+    const source = xsn._from[0]._origin;
+    csn.$origin = originRef( source );
+    if (source.params && !xsn.params)
+      csn.params = null;        // discontinue `params` inheritance
+    if (source.actions && !xsn.actions)
+      csn.actions = null;       // discontinue `actions` inheritance
+    return;
+  }
+  else if (xsn.includes) {
+    csn.$origin = includesOrigin( xsn.includes, xsn );
+    return;
   }
-  else if (xsn.includes && xsn.includes.length > 1) {
-    csn.$origin = { $origin: originRef( xsn.includes[0]._artifact ) };
+  else if (!xsn._main || xsn.kind === 'select') {
+    return;
   }
-  else if (xsn._origin && !hasExplicitProp( xsn.type ) && xsn._origin.kind !== 'builtin') {
-    let origin = xsn._origin;
-    while (origin._parent && origin._parent.$expand === 'origin')
-      origin = origin._origin || origin.type._artifact;
-    csn.$origin = originRef( origin );
+  const parent = getParent( xsn );
+  const parentOrigin = getOrigin( parent );
+  if (!xsn._origin || xsn._origin.kind === 'builtin') { // or $dollarVariable
+    if (parentOrigin && (!parent.enum || parent.$origin || !parent.type))
+      csn.$origin = null;
+    return;
   }
-  return csn;
+  // Skip all proxies which do not make it into the CSN, as there are no
+  // individual annotations or redirection targets on it:
+  while (origin._parent && origin._parent.$expand === 'origin')
+    origin = origin._origin || origin.type._artifact;
+  // The while loop is not only for the else case below: when setting implicit
+  // prototypes, it is important that we do not have to follow the prototypes of
+  // other object; we would need to ensure a right order to avoid issues otherwise.
+  if (parentOrigin === getParent( origin )) {
+    // implicit prototype or shortened reference
+    const { id } = origin.name || {};
+    if (id && xsn.name && id !== xsn.name.id)
+      csn.$origin = id;
+    return;
+  }
+  if (origin.kind === 'mixin') {
+    // currently, target and on are always set - nothing to do here, just set type
+    csn.type = 'cds.Association';
+    return;
+  }
+  const ref = originRef( origin, xsn );
+  if (ref) {
+    csn.$origin = ref;
+    return;
+  }
+  // An element of a query with a query in FROM:
+  const anon = definition( origin );   // use $origin: {...} if necessary
+  // as there are no implicit $origin prototypes on sub query elements (yet),
+  // we do not have to care about $origin not being set
+  const { $origin } = anon;
+  if ($origin && typeof $origin === 'object' && !Array.isArray( $origin )) {
+    // repeated anon: flatten
+    csn.$origin = Object.assign( $origin, anon );
+  }
+  else if (Object.keys( anon )
+           // (we can use the properties in `csn`, because addOrigin() is called last)
+    .every( p => p in csn || p === '$origin' || p === '$location')) {
+    // nothing new in $origin: {...}
+    addOrigin( csn, xsn, origin._origin );
+  }
+  else {
+    csn.$origin = anon;
+  }
+}
+
+function getParent( art ) {
+  const parent = art._parent;
+  const main = parent._main;
+  return (main && parent === main._leadingQuery) ? main : parent;
+}
+
+function getOrigin( art ) {
+  if (art._origin)
+    return art._origin;
+  if (hasExplicitProp( art.type ))
+    return art.type._artifact;
+  if (art.includes)
+    return art.includes[0]._artifact;
+  if (art._from)
+    return art._from[0]._origin;
+  return undefined;
 }
 
 function hasExplicitProp( ref ) {
   return ref && !ref.$inferred;
 }
 
-function originRef( art ) {
+function originRef( art, user ) {
   const r = [];
   // do not use name.element, as we allow `.`s in name
-  let main = art;
-  while (main._main && main.kind !== 'select') {
-    const nkind = normalizedKind[main.kind];
-    if (main.name.id || !r.length) // { param: "" } only for return, not elements inside
-      r.push( nkind ? { [nkind]: main.name.id } : main.name.id );
-    main = main._parent;
+  let parent = art;
+  while (parent._main && parent.kind !== 'select') {
+    const nkind = normalizedKind[parent.kind];
+    if (parent.name.id || !r.length)
+      // Return parameter is in XSN - kind: 'param', name.id: ''
+      // eslint-disable-next-line no-nested-ternary, max-len
+      r.push( !nkind ? parent.name.id : parent.name.id ? { [nkind]: parent.name.id } : { return: true } );
+    parent = parent._parent;
   }
-  if (main._main)    // well, an element of an query in FROM
-    return definition( art );   // use $origin: {}
+  if (user && parent._main && parent._main === user._main && parent !== user._main._leadingQuery)
+    // well, an element of an query in FROM (TODO: try with sub elem), but not the leading query
+    return null;                // probably use $origin: {...}
   // for sub query in FROM in sub query in FROM, we could condense the info
+
+  // Now the ref, with ["absolute", "action"] instead of ["absolute", {action:"action"}]
+  if (r.length === 1 && normalizedKind[art.kind] === 'action')
+    return [ art.name.absolute, art.name.id ];
   r.push( art.name.absolute );
   r.reverse();
   return r;
@@ -853,13 +987,11 @@ function kind( k, csn, node ) {
     else if (k === 'extend')
       csn.kind = k;
   }
-  else {
-    if (![
-      'element', 'key', 'param', 'enum', 'select', '$join',
-      '$tableAlias', 'annotation', 'mixin',
-    ].includes(k))
-      csn.kind = k;
-    addOrigin( csn, node );
+  else if (![
+    'element', 'key', 'param', 'enum', 'select', '$join',
+    '$tableAlias', 'annotation', 'mixin',
+  ].includes(k)) {
+    csn.kind = k;
   }
 }
 
@@ -997,7 +1129,10 @@ function value( node ) {
 
 function enumValue( v, csn, node ) {
   // Enums can have values but if enums are extended, their kind is 'element',
-  // so we check whether the node is inside an extension.
+  // so we check whether the node is inside an extension. (TODO: still?)
+  if (universalCsn && v.$inferred)
+    return;
+  // (with gensrc, the symbol itself would not make it into the CSN)
   if (node.kind === 'enum' || node._parent && node._parent.kind === 'extend')
     Object.assign( csn, expression( v, true ) );
 }
@@ -1185,7 +1320,7 @@ function columns( xsnColumns, csn, xsn ) {
         addElementAsColumn( col, csnColumns );
     }
   }
-  else {                        // null = use elements
+  else {            // null = use elements - TODO: still used by A2J? -> remove
     for (const name in xsn.elements)
       addElementAsColumn( xsn.elements[name], csnColumns );
   }

package/lib/language/antlrParser.js

@@ -162,6 +162,17 @@ function parse( source, filename = '<undefined>.cds', options = {}, messageFunct
   if (rulespec.$frontend)
     ast.$frontend = rulespec.$frontend;
 
+  // Warn about unused doc-comments.
+  // Do not warn if docComments are explicitly disabled.
+  if (options.docComment !== false) {
+    for (const token of tokenStream.tokens) {
+      if (token.channel === antlr4.Token.HIDDEN_CHANNEL && token.type === parser.constructor.DocComment && !token.isUsed) {
+        messageFunctions.info('syntax-ignoring-doc-comment', parser.multiLineTokenLocation(token), {},
+          "Ignoring doc-comment as it does not belong to any artifact");
+      }
+    }
+  }
+
   // TODO: clarify with LSP colleagues: still necessary?
   if (parser.messages) {
     Object.defineProperty( ast, 'messages',

package/lib/language/genericAntlrParser.js

@@ -49,6 +49,8 @@ GenericAntlrParser.prototype = Object.assign(
     attachLocation,
     startLocation,
     tokenLocation,
+    multiLineTokenLocation,
+    previousTokenAtLocation,
     combinedLocation,
     surroundByParens,
     unaryOpForParens,
@@ -245,9 +247,12 @@ function prepareGenericKeywords( pathItem ) {
   // TODO: If not just at the beginning, we need a stack for $genericKeywords,
   // as we can have nested special functions
   this.$genericKeywords.argFull = Object.keys( spec );
+  // @ts-ignore
   const token = this.getCurrentToken() || { text: '' };
-  if (spec[token.text.toUpperCase()] === 'argFull')
+  if (spec[token.text.toUpperCase()] === 'argFull') {
+    // @ts-ignore
     token.type = this.constructor.GenericArgFull;
+  }
 }
 
 // Attach location matched by current rule to node `art`.  If a location is
@@ -297,7 +302,7 @@ function tokenLocation( token, endToken, val ) {
     file: this.filename,
     line: token.line,
     col: token.column + 1,
-    // we only have single-line tokens
+    // we only have single-line tokens, except for docComments
     endLine: endToken.line,
     endCol: endToken.stop - endToken.start + endToken.column + 2, // after the last char (special for EOF?)
   };
@@ -306,6 +311,51 @@ function tokenLocation( token, endToken, val ) {
   return r;
 }
 
+/**
+ * Return location of `token`.  In contrast to `tokenLocation()`, this function
+ * can handle multiline tokens.
+ */
+function multiLineTokenLocation(token, val) {
+  if (!token)
+    return undefined;
+
+  // Count the number of newlines in the token.
+  // TODO: I want to avoid a substring, that's why I don't use RegEx here
+  const source = token.source[1].data;
+  let newLineCount = 0;
+  let lastNewlineIndex = token.start;
+  for (let i = token.start; i < token.stop; i++) {
+    if (source[i] === 10) { // ASCII code for '\n'
+      newLineCount++;
+      lastNewlineIndex = i;
+    }
+  }
+  if (newLineCount === 0)
+    // endCol calculation below requires at least one newLine.
+    return this.tokenLocation(token, token, val);
+
+  /** @type {CSN.Location} */
+  const r = {
+    file: this.filename,
+    line: token.line,
+    col: token.column + 1,
+    endLine: token.line + newLineCount,
+    endCol: token.stop - lastNewlineIndex + 1, // after the last char (special for EOF?)
+  };
+  if (val !== undefined)
+    return { location: r, val };
+  return r;
+}
+
+function previousTokenAtLocation( location ) {
+  let k = -1;
+  let token = this._input.LT(k);
+  while (token.line > location.line ||
+         token.line === location.line && token.column >= location.col)
+    token = this._input.LT(--k);
+  return (token.line === location.line && token.column + 1 === location.col) && token;
+}
+
 // Create a location with location properties `filename` and `start` from
 // argument `start`, and location property `end` from argument `end`.
 function combinedLocation( start, end ) {
@@ -342,16 +392,20 @@ function unaryOpForParens( query, val ) {
 //  - would influence the prediction, probably even induce adaptivePredict() calls,
 //  - is only slightly "more declarative" in the grammar.
 function docComment( node ) {
-  if (!this.options.docComment)
-    return;
   const token = this._input.getHiddenTokenToLeft( this.constructor.DocComment );
   if (!token)
     return;
+
+  // This token is actually used by / assigned to an artifact.
+  token.isUsed = true;
+
+  if (!this.options.docComment)
+    return;
   if (node.doc) {
     this.warning( 'syntax-duplicate-doc-comment', token, {},
                   'Repeated doc comment - previous doc is replaced' );
   }
-  node.doc = this.tokenLocation( token, token, parseDocComment( token.text ) );
+  node.doc = this.multiLineTokenLocation( token, parseDocComment( token.text ) );
 }
 
 // Classify token (identifier category) for implicit names,
@@ -435,14 +489,18 @@ function valuePathAst( ref ) {
     path.length = 1;
   }
   const { args, id, location } = path[0];
-  if (args) {
-    if (path[0].$syntax !== ':')
-      return { op: { location, val: 'call' }, func: ref, location: ref.location, args };
-  }
-  else if (!path[0].$delimited && functionsWithoutParens.includes( id.toUpperCase() )) {
-    return { op: { location, val: 'call' }, func: ref, location: ref.location };
-  }
-  return ref;
+  if (args
+      ? path[0].$syntax === ':'
+      : path[0].$delimited || !functionsWithoutParens.includes( id.toUpperCase() ))
+    return ref;
+
+  const implicit = this.previousTokenAtLocation( location );
+  if (implicit && implicit.isIdentifier)
+    implicit.isIdentifier = 'func';
+  const op = { location, val: 'call' };
+  return (args)
+    ? { op, func: ref, location: ref.location, args }
+    : { op, func: ref, location: ref.location };
 }
 
 // If a '-' is directly before an unsigned number, consider it part of the number;
@@ -601,7 +659,7 @@ function addDef( parent, env, kind, name, annos, props, location ) {
     // which could be tested in name search (then no undefined-ref error)
     return art;
   }
-  else if (env === 'artifacts') {
+  else if (env === 'artifacts' || env === 'vocabularies') {
     dictAddArray( parent[env], art.name.id, art );
   }
   else if (kind || this.options.parseOnly) {

package/lib/language/language.g4

@@ -498,6 +498,8 @@ projectionSpec returns[ query ] locals[ src ]
       fromPath[ $src, 'ref']
     )?
     ( AS aliasName=ident['FromAlias'] { $src.name = $aliasName.id } )?
+    // ANTLR errors are better if we use ( A )? instead of ( A | ):
+    { if (!$src.name) this.classifyImplicitName( $src.scope ? 'FromAlias' : 'Without' ); }
     bracedSelectItemListDef[ $query ]?
     excludingClause[ $query ]?
   ;
@@ -1776,6 +1778,62 @@ partitionByClause returns [ expr ]
     ( ',' en=expression { $expr.args.push( $en.expr ); } )*
   ;
 
+windowFrameClause returns [ wf ]
+  :
+    r=ROWS { $wf = { op: this.tokenLocation($r, null, 'rows' ) , args: [] }}
+    wfe=windowFrameExtentSpec { $wf.args.push( $wfe.wfe ); }
+  ;
+
+windowFrameExtentSpec returns[ wfe ]
+  :
+    { $wfe = {} }
+    windowFrameStartSpec [ $wfe ]
+  |
+    b=BETWEEN
+    { $wfe = { op: this.tokenLocation( $b, null, 'frameBetween' ), args: [] } }
+    wfb1=windowFrameBoundSpec { $wfe.args.push( $wfb1.wfb ); }
+    AND
+    wfb2=windowFrameBoundSpec { $wfe.args.push( $wfb2.wfb ); }
+  ;
+
+windowFrameBoundSpec returns [ wfb ]
+@after{ /* #ATN 1 */ }
+  :
+    // #ATN:  Not ll1 because `UNBOUNDED` could also be part of the windowFrameStartSpec
+    //        `UNBOUNDED` would then be immediately followed by `PRECEDING`
+    u=UNBOUNDED f=FOLLOWING
+    { $wfb = { op: this.tokenLocation($u, $f, 'unboundedFollowing' ), args: []} }
+  |
+    // #ATN:  Not ll1 because `Number` could also be part of the windowFrameStartSpec
+    //        `Number` would then be immediately followed by `PRECEDING`
+    n=Number f=FOLLOWING
+    { $wfb = { op: this.tokenLocation($n, $f, 'following' ), args: [ this.numberLiteral( $n ) ]} }
+  |
+    { $wfb = {} }
+    windowFrameStartSpec [ $wfb ]
+  ;
+
+windowFrameStartSpec [ wf ]
+  :
+    u=UNBOUNDED p=PRECEDING
+    {
+      $wf.op = this.tokenLocation($u, $p, 'unboundedPreceding' );
+      $wf.args = [];
+    }
+  |
+    n=Number p=PRECEDING
+    {
+      $wf.op = this.tokenLocation($p, null, 'preceding' );
+      $wf.args = [ this.numberLiteral( $n ) ];
+    }
+  | 
+    c=CURRENT r=ROW
+    {
+      $wf.op = this.tokenLocation($c, $r, 'currentRow' );
+      $wf.args = [];
+    }
+  ;
+
 overClause returns [ over ]
 @after { this.attachLocation($over); }
   :
@@ -1783,6 +1841,7 @@ overClause returns [ over ]
     '('
       ( pb=partitionByClause { $over.args.push( $pb.expr ); } )?
       ( ob=overOrderByClause { $over.args.push( $ob.expr ); } )?
+      ( wf=windowFrameClause { $over.args.push( $wf.wf ); } )?
     ')'
   ;
 
@@ -1948,6 +2007,8 @@ tableTerm returns [ table ]
       // if we would use rule `ident`, we would either had to make all JOIN
       // kinds reserved or introduce ATN
     )?
+    // ANTLR errors are better if we use ( A | B )? instead of ( A | B | ):
+    { if (!$table.name) this.classifyImplicitName( $table.scope ? 'FromAlias' : 'Without' ); }
   |
     open='('
     // #ATN: The following alternative is not LL1, because both can start with
@@ -2602,6 +2663,7 @@ ident[ category ] returns[ id ]
   | COMPOSITION
   | CONTEXT
   | CROSS
+  | CURRENT
   | DAY
   | DEFAULT
   | DEFINE
@@ -2619,6 +2681,7 @@ ident[ category ] returns[ id ]
   | EXTEND
   | FIRST
   | FLOATING
+  | FOLLOWING
   | FULL
   | FUNCTION
   | GROUP
@@ -2650,10 +2713,13 @@ ident[ category ] returns[ id ]
   | OUTER
   | PARAMETERS
   | PARTITION
+  | PRECEDING
   | PROJECTION
   | REDIRECTED
   | RETURNS
   | RIGHT
+  | ROW
+  | ROWS
   | SECOND
   | SERVICE
   | THEN
@@ -2662,6 +2728,7 @@ ident[ category ] returns[ id ]
   | TO
   | TYPE
   | USING
+  | UNBOUNDED
   | VARIABLE
   | VIEW
   | YEAR
@@ -2763,6 +2830,7 @@ BOTH : [bB][oO][tT][hH] ;
 COMPOSITION : [cC][oO][mM][pP][oO][sS][iI][tT][iI][oO][nN] ;
 CONTEXT : [cC][oO][nN][tT][eE][xX][tT] ;
 CROSS : [cC][rR][oO][sS][sS] ;
+CURRENT : [cC][uU][rR][rR][eE][nN][tT] ;
 DAY : [dD][aA][yY] ;
 DEFAULT : [dD][eE][fF][aA][uU][lL][tT] ;
 DEFINE : [dD][eE][fF][iI][nN][eE] ;
@@ -2780,6 +2848,7 @@ EXCLUDING : [eE][xX][cC][lL][uU][dD][iI][nN][gG] ;
 EXTEND : [eE][xX][tT][eE][nN][dD] ;
 FIRST : [fF][iI][rR][sS][tT] ;
 FLOATING : [fF][lL][oO][aA][tT][iI][nN][gG] ;
+FOLLOWING : [fF][oO][lL][lL][oO][wW][iI][nN][gG] ;
 FULL : [fF][uU][lL][lL] ;
 FUNCTION : [fF][uU][nN][cC][tT][iI][oO][nN] ;
 GROUP : [gG][rR][oO][uU][pP] ;
@@ -2812,10 +2881,13 @@ OUTER : [oO][uU][tT][eE][rR] ;
 // OVER : [oO][vV][eE][rR] ;
 PARAMETERS : [pP][aA][rR][aA][mM][eE][tT][eE][rR][sS] ;
 PARTITION: [pP][aA][rR][tT][iI][tT][iI][oO][nN] ;
+PRECEDING: [pP][rR][eE][cC][eE][dD][iI][nN][gG] ;
 PROJECTION : [pP][rR][oO][jJ][eE][cC][tT][iI][oO][nN] ;
 REDIRECTED : [rR][eE][dD][iI][rR][eE][cC][tT][eE][dD] ;
 RETURNS : [rR][eE][tT][uU][rR][nN][sS] ;
 RIGHT : [rR][iI][gG][hH][tT] ;
+ROW : [rR][oO][wW] ;
+ROWS : [rR][oO][wW][sS] ;
 SECOND : [sS][eE][cC][oO][nN][dD] ;
 SERVICE : [sS][eE][rR][vV][iI][cC][eE] ;
 THEN : [tT][hH][eE][nN] ;
@@ -2823,6 +2895,7 @@ TRAILING : [tT][rR][aA][iI][lL][iI][nN][gG] ;
 TO : [tT][oO] ;                 // or make reserved? (is in SQL-92)
 TYPE : [tT][yY][pP][eE] ;
 UNION : [uU][nN][iI][oO][nN] ;
+UNBOUNDED : [uU][nN][bB][oO][uU][nN][dD][eE][dD] ;
 USING : [uU][sS][iI][nN][gG] ;
 VARIABLE : [vV][aA][rR][iI][aA][bB][lL][eE] ;
 VIEW : [vV][iI][eE][wW] ;