Merge branch 'main' into add_open_rewrite

Author: renejeglinsky

.vitepress/theme/components/ConfigInspect.vue

@@ -36,12 +36,13 @@
   import FloatingVue from 'floating-vue'
   import yaml from 'yaml'
 
-  const { java, keyOnly, filesOnly, showPrivate, label:labelProp } = defineProps<{
+  const { java, keyOnly, filesOnly, showPrivate, label:labelProp, keyDelim } = defineProps<{
     java?: boolean,
     keyOnly?: boolean,
     filesOnly?: boolean,
     showPrivate?: boolean,
-    label?: string
+    label?: string,
+    keyDelim?: string
   }>()
 
   // sub component that renders code blocks similar to the markdown `::: code-block` syntax
@@ -85,6 +86,7 @@
 
   const [key, val] = slotVal.split(/\s*[:=]\s*(.*)/) // split on first `:` or `=`
   const label = labelProp || `${keyOnly ? key: slotVal}`
+  const keyDel = keyDelim ?? '.'
 
   const cfgKey = ref()
   const popperVisible = ref(false)
@@ -114,25 +116,25 @@
 
     let jsonVal
     if (typeof value === 'string' && value.trim().match(/^[[{].*[\]}]$/)) { try { jsonVal = JSON.parse(value) } catch {/*ignore*/ } }
-    const pkg = toJson(key, jsonVal ?? value)
+    const pkg = toJson(key, jsonVal ?? value, keyDel)
 
     pkgStr.value = JSON.stringify(pkg, null, 2)
     rcJsonStr.value = JSON.stringify(pkg.cds??{}, null, 2)
     rcJsStr.value = 'module.exports = ' + rcJsonStr.value.replace(/"(\w*?)":/g, '$1:')
     rcYmlStr.value = yaml.stringify(pkg.cds)
-    propStr.value = `${key}=${jsonVal ? JSON.stringify(jsonVal) : value}`
 
-    let envKey = key.replaceAll('_', '__').replaceAll('.', '_')
+    let envKey = key.replaceAll('_', '__').replaceAll(keyDel, '_')
     if (/^[a-z_]+$/.test(envKey)) envKey = envKey.toUpperCase() // only uppercase if not camelCase
     envStr.value = `${envKey}=${jsonVal ? JSON.stringify(jsonVal) : value}`
+    propStr.value = `${envKey}=${jsonVal ? JSON.stringify(jsonVal) : value}`
 
     javaAppyml.value = yaml.stringify(pkg)
     javaEnvStr.value = `-D${propStr.value}`
   })
 
-function toJson(key:string, value:string): Record<string, any> {
+function toJson(key:string, value:string, delim:string): Record<string, any> {
   let res  = {}
-  const parts = key.split('.')
+  const parts = key.split(delim)
   parts.reduce((r:Record<string,any>, a, i) => {
     r[a] = r[a] || (i < parts.length-1 ? {} : value)
     return r[a];

.vitepress/theme/styles.scss

@@ -115,11 +115,11 @@ main {
     // Custom list styles for nested items
     ul {
       list-style-type: disc; // First level: filled circle
-      
+
       ul {
         list-style-type: circle; // Second level: empty circle
-        
-        
+
+
         ul {
           list-style-type: square; // Third level: square
         }
@@ -551,15 +551,14 @@ html.node {
   pre.log:focus {
     min-width: fit-content;
     padding-right: 40px;
-    z-index: 1;  // draw over outline
+    z-index: 1; position: relative; // draw over outline
   }
   table:hover,
   table:focus {
     min-width: fit-content;
   }
-  tr { // make wide rows go over outline, not below it
-    z-index: 1;
-    position: relative;
+  tr {
+    z-index: 1; position: relative;  // draw wide rows over outline
   }
   [class*='language-'] pre {
     overflow: hidden !important;

cds/cdl.md

@@ -41,7 +41,7 @@ The *Conceptual Definition Language (CDL)* is a human-readable language for defi
 
 ```cds
 namespace capire.bookshop;
-using { managed, cuid } from `@sap/cds/common`;
+using { managed, cuid } from '@sap/cds/common';
 aspect primary : managed, cuid {}
 
 entity Books : primary {
@@ -85,7 +85,7 @@ The following literals can be used in CDL (mostly as in JavaScript, Java, and SQ
 <!-- cds-mode: ignore; values only, no valid CDS file -->
 ```cds
 true , false , null        // as in all common languages
-11 , 2.4 , 1e3, 1.23e-11   // for numbers
+11 , 2.4 , 1e3 , 1.23e-11  // for numbers
 'A string''s literal'      // for strings
 `A string\n paragraph`     // for strings with escape sequences
 { foo:'boo', bar:'car' }   // for records
@@ -130,6 +130,10 @@ entity DocumentedEntity {
 }
 ```
 
+::: tip
+These annotations are illustrative only and are not defined nor have any meaning beyond this example.
+:::
+
 Within those strings, escape sequences from JavaScript, such as `\t` or `\u0020`, are supported. Line endings are normalized. If you don't want a line ending at that position, end a line with a backslash (`\`). For string literals inside triple backticks, indentation is stripped and tagging is possible.
 
 
@@ -238,7 +242,7 @@ context scoped {
 
 You can define types and entities with other definitions' names as prefixes:
 
-```cds
+```cds [prefixes.cds]
 namespace foo.bar;
 entity Foo {}           //> foo.bar.Foo
 entity Foo.Bar {}       //> foo.bar.Foo.Bar
@@ -248,7 +252,7 @@ type Foo.Bar.Car {}     //> foo.bar.Foo.Bar.Car
 
 #### Fully Qualified Names
 
-A model ultimately is a collection of definitions with unique, fully qualified names. For example, the second model above would compile to this [CSN](./csn):
+A model ultimately is a collection of definitions with unique, fully qualified names. For example, the model in `contexts.cds` would compile to the following [CSN](./csn):
 
 ::: code-group
 

cds/types.md

@@ -36,7 +36,7 @@ These types are used to define the structure of entities and services, and are m
 | `Decimal` (`prec`, `scale`) | A *decfloat* type is used if arguments are omitted | _DECIMAL_  |
 | `Double` | Floating point with binary mantissa | _DOUBLE_  |
 | `Date` | e.g. `2022-12-31` | _DATE_  |
-| `Time` | e.g. `24:59:59` | _TIME_  |
+| `Time` | e.g. `23:59:59` | _TIME_  |
 | `DateTime` | _sec_ precision | _TIMESTAMP_  |
 | `Timestamp` | _µs_ precision, with up to 7 fractional digits |  _TIMESTAMP_  |
 | `String` (`length`) | Default *length*: 255; on HANA: 5000 <sup>(4)(5)</sup> | _NVARCHAR_  |
@@ -46,8 +46,6 @@ These types are used to define the structure of entities and services, and are m
 | `Map` | Mapped to *NCLOB* for HANA. | *JSON* type |
 | `Vector` (`dimension `) | Requires SAP HANA Cloud QRC 1/2024, or later |  _REAL_VECTOR_  |
 
-These types are used to define the structure of entities and services, and are mapped to respective database types when the model is deployed.
-
 > <sup>(1)</sup> Concrete mappings to specific databases may differ.
 >
 > <sup>(2)</sup> See also [Best Practices](../guides/domain-modeling#don-t-interpret-uuids).

java/cqn-services/persistence-services.md

@@ -50,8 +50,7 @@ CAP Java SDK is tested on [PostgreSQL](https://www.postgresql.org/) 15 and suppo
 
 1. No locale specific sorting. The sort order of queries behaves as configured on the database.
 2. Write operations through CDS views are only supported for views that can be [resolved](../working-with-cql/query-execution#updatable-views) or are [updatable](https://www.postgresql.org/docs/14/sql-createview.html#SQL-CREATEVIEW-UPDATABLE-VIEWS) in PostgreSQL.
-3. The CDS type `UInt8` can't be used with PostgreSQL, as there's no `TINYINT`. Use `Int16` instead.
-4. [Multitenancy](../../guides/multitenancy/) and [extensibility](../../guides/extensibility/) aren't yet supported on PostgreSQL.
+3. [Multitenancy](../../guides/multitenancy/) and [extensibility](../../guides/extensibility/) aren't yet supported on PostgreSQL.
 
 ### H2 Database
 
@@ -62,8 +61,7 @@ CAP Java SDK is tested on [PostgreSQL](https://www.postgresql.org/) 15 and suppo
 3. By default, views aren't updatable on H2. However, the CAP Java SDK supports some views to be updatable as described [here](../working-with-cql/query-execution#updatable-views).
 4. Although referential and foreign key constraints are supported, H2 [doesn't support deferred checking](https://www.h2database.com/html/grammar.html#referential_action). As a consequence, schema SQL is never generated with referential constraints.
 5. In [pessimistic locking](../working-with-cql/query-execution#pessimistic-locking), _shared_ locks are not supported but an _exclusive_ lock is used instead.
-6. The CDS type `UInt8` can't be used with H2, as there is no `TINYINT`. Use `Int16` instead.
-7. For regular expressions, H2's implementation is compatible with Java's: the matching behaviour is an equivalent of the `Matcher.find()` call for the given pattern.
+6. For regular expressions, H2's implementation is compatible with Java's: the matching behaviour is an equivalent of the `Matcher.find()` call for the given pattern.
 
 ::: warning
 Support for localized and temporal data via session context variables requires H2 v2.2.x or later.