@sap/xsodata 7.4.5 → 8.0.0

package/CHANGELOG.md

@@ -8,6 +8,31 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ## Unreleased
 
+## [8.0.0] - 2022-08-04
+
+* HANA Cloud database support added
+* Public synonym support added
+* Update module dependencies
+
+## [7.5.5] - 2022-04-21
+
+* On calc view: Stable sort order with $skip and $top usage for subsequent requests via "order by" of key fields in SQL statement
+
+## [7.5.4] - 2022-04-21
+
+Build infrastructure fix
+
+## [7.5.1] - [7.5.3] - 2022-04-20
+
+Build infrastructure fixes
+
+## [7.5.0] - 2022-03-22
+
+* Support of node version 16
+* Update module dependencies
+* Update of system query options and xsodata-settings help text
+* Minor changes: Error reporting
+
 ## [7.4.5] - 2021-12-15
 
 * Suppress $metadata annotation <code>sap:aggregation-role="dimension"</code> on calculation view property if it is used as description property referenced by annotation <code>sap:text</code> by another property of the calulation view. The annotation is only supressed if the corresponding xsodata-file has <code>settings</code> containing this: <code>noDimensionAnnoOnTextProperty true;</code>

package/lib/db/connect.js

@@ -1,4 +1,5 @@
 'use strict';
+
 /**
  * Add  <db> attribute to <context>
  * Uses <context>.<handlerConfiguration.dbConfiguration>
@@ -60,13 +61,48 @@ function loadDbVersion(context, asyncDone) {
             context.logger.info('xsodata', 'db version: ' + version);
             context.gModel.setDbVersion(version);
         } else {
-            context.gModel.setDbVersion(null); // don't try reload
+            context.gModel.setDbVersion(null);  // don't try reload
+        }
+
+        return asyncDone(null, context);
+    });
+}
+
+function setHanaCloudContext(context, asyncDone) {
+
+    return context.db.client.exec('select version from "SYS"."M_DATABASE"', function (err, rows) {
+        if (err) {
+            return asyncDone(new SqlError(context, err), context);
+        }
+
+        if (rows && rows[0] && rows[0].VERSION) {
+            const version = rows[0].VERSION;
+            context.logger.info('xsodata', 'db version: ' + version);
+            context.db.isHanaCloudDb = isHanaCloudDb(context, rows[0].VERSION);
+            context.logger.info('xsodata', `isHanaCloud: ${context.db.isHanaCloudDb} (DB version based)`);
+        } else {
+            // 06/2022:
+            // Currently all SQL from Hana Cloud work also on Hana Service, i.e. take that version as default;
+            // could be changed in the future, i.e. using the context setting of 'context.db.isHanaCloudDb'
+            context.db.isHanaCloudDb = true;
+            context.logger.info('xsodata', `isHanaCloud: ${context.db.isHanaCloudDb} (default)`);
         }
 
         return asyncDone(null, context);
     });
 }
 
+function isHanaCloudDb(context, version) {
+    const regex = /^([0-9])+\..*$/;
+    let result = version.match(regex);
+
+    if (result && result[1]) {
+        return (result[1] >= 4);
+    } else {
+        context.logger.error(`DB Version parsing failed: ${version}`);
+        return true;        // default: Hana Cloud
+    }
+}
 
 function getDbClientType(dbClient) {
     if (dbClient._settings) {
@@ -97,6 +133,8 @@ function prepareConnection(context, asyncDone) {
     // Set the isolation level
     executeList.push(utils.tryAndMeasure(execSQL, 'SET TRANSACTION ISOLATION LEVEL REPEATABLE READ', 'execSQL (isolation level)'));
     executeList.push(loadDbVersion);
+    // Set Hana Cloud indicator in context
+    executeList.push(setHanaCloudContext);
 
     async.waterfall(
         executeList,
@@ -163,9 +201,6 @@ function _connectInternal(context, asyncDone) {
 
 
     try {
-        context.logger.silly('connect - db', 'use hdb.createClient');
-
-
         let db_module = null;
 
         if (context.handlerConfiguration.dbClient === 'hdb') {
@@ -173,11 +208,13 @@ function _connectInternal(context, asyncDone) {
                 hdb_module = require('hdb');
             }
             db_module = hdb_module;
+            context.logger.silly('connect - db', 'use hdb.createClient');
         } else {
             if (!hana_client_module) {
                 hana_client_module = require('@sap/hana-client');
             }
             db_module = hana_client_module;
+            context.logger.silly('connect - db', 'use hana-client');
         }
 
 
@@ -250,6 +287,7 @@ exports.connect = function (context, asyncDone) {
         }
         context.logger.debug('connect - db', 'connection is usable');
         context.db.connectionInitialized = true;
+        context.logger.debug('connect - context setting - Is Hana Cloud used?', `${context.db.isHanaCloudDb}`);
         return asyncDone(null, context);
 
     });

package/lib/db/dbSegment.js

@@ -92,6 +92,13 @@ function DbSegment(kind, entityType, nr) {
      * @type {Array<String>}
      */
     this._SelectedPropertiesOrdered = null;
+
+    /**
+     * For CV: (real) key names with alias
+     * @type {Array<String,string>}
+     */
+    this._aliasedKeyPropertiesOnCalcView = [];
+
     /**
      * Store names existing of navigation properties
      * @type {Array<String>}
@@ -593,6 +600,50 @@ DbSegment.prototype.getKeyProperties0123ForSelectAs0123 = function (noTable) {
     return ret;
 };
 
+DbSegment.prototype.getKeyProperties0123ForSelectOnCalcViewAs0123 = function (noTable) {
+    let ret = [];
+    let keyNames;
+    let keyName;
+    let property;
+    let selectProperty;
+    let propertyType;
+    let i;
+    let j = -1;
+
+    keyNames = this.entityType.keyNamesOrdered;
+
+    for (i = 0; i < keyNames.length; i++) {
+        keyName = keyNames[i];
+        property = this.entityType.propertiesMap[keyName];
+        selectProperty = null;
+
+        if (property.KIND !== EntityType.entityKind.inputParameters) {
+            j = j + 1;      // for real key properties use numbering: 0,1,2, ... (skip CV input params)
+            propertyType = property.aggregate ? null : property.DATA_TYPE_NAME;
+            selectProperty = new sqlStatement.SelectProperty(noTable ? null : this._Alias, keyName, propertyType, j.toString());
+            ret.push(selectProperty);
+        }
+    }
+    return ret;
+};
+
+DbSegment.prototype.setAliasedKeyPropertiesOnCalcView = function(selectProperties) {
+    this._aliasedKeyPropertiesOnCalcView = selectProperties;
+};
+
+DbSegment.prototype.hasAliasedKeyPropertiesOnCalcView = function() {
+    return this._aliasedKeyPropertiesOnCalcView.length !== 0;
+};
+
+DbSegment.prototype.getAliasedKeyPropertyOnCalcView = function(propertyName) {
+    for (let i = 0; i < this._aliasedKeyPropertiesOnCalcView.length; i++) {
+        if (this._aliasedKeyPropertiesOnCalcView[i].property === propertyName) {
+            return this._aliasedKeyPropertiesOnCalcView[i];
+        }
+    }
+    return null;
+};
+
 /**
  * Returns a selectProperty for usage in the select part of sql statements
  * The property are named "0","1","2",... and have as type the type of the corresponding key ( ordered by position
@@ -649,7 +700,30 @@ DbSegment.prototype.getKeyProperties0123ForOrderBy = function (noTable) {
     return ret;
 };
 
-DbSegment.prototype.getKeyPropertiesNotSelectedForSelect = function (noTable) {
+DbSegment.prototype.getKeyProperties0123ForOrderByCalcView = function (noTable) {
+    let ret = [];
+    let keyName;
+    let property;
+	let j = -1;
+
+    let keyNames = this.entityType.keyNamesOrdered;
+
+    for (let i = 0; i < keyNames.length; i++) {
+
+        keyName = keyNames[i];
+        property = this.entityType.propertiesMap[keyName];
+
+		if (property.KIND !== EntityType.entityKind.inputParameters) {
+			j = j + 1;
+            let newSortOrder = new typedObjects.SortOrder(new typedObjects.Property(j.toString(), noTable ? null : this._Alias), 'ASC');
+            newSortOrder.setPropertyName(property.COLUMN_NAME);
+            ret.push(newSortOrder);
+		}
+    }
+    return ret;
+};
+
+DbSegment.prototype.getKeyPropertiesNotSelectedForSelect = function (noTable = undefined, inputParameters = null) {
     let ret = [];
     let keyNames;
     let i;
@@ -659,6 +733,18 @@ DbSegment.prototype.getKeyPropertiesNotSelectedForSelect = function (noTable) {
 
     keyNames = this.entityType.keyNamesOrdered;
 
+    // remove input params from key list
+    if (inputParameters !== null) {
+        for (let inputParameterName in inputParameters) {
+            if (inputParameters.hasOwnProperty(inputParameterName)) {
+                let indexKeyName = keyNames.indexOf(inputParameterName);
+                if (indexKeyName > -1) {
+                    keyNames.splice(indexKeyName, 1);
+                }
+            }
+        }
+    }
+
     for (i = 0; i < keyNames.length; i++) {
         keyName = keyNames[i];
         key = this.entityType.propertiesMap[keyName];

package/lib/model/entityType.js

@@ -43,6 +43,12 @@ function EntityType(entityType, settings) {
     this.path = this._entityType.path;
     this.keys = determineKeys(this._entityType);
 
+    // virtual table / virtual view data (includes synonyms + virtual tables)
+    this._isVirtual = false;
+    this._virtualObjectSchema = null;
+    this._virtualObjectName = null;
+    this._remoteSource = null;
+
     // in .xsodata as "entityname" --> null
     // in .xsodata as "entityname" concurrencytoken; --> {}
     // in .xsodata as "entityname" concurrencytoken ("KEY"); --> { key : true }
@@ -107,6 +113,12 @@ function EntityType(entityType, settings) {
     this._admindata = prepareAdmindata(this._settings.admindata, this._entityType.admindata);
 }
 
+EntityType.prototype.setVirtualInfo = function(objectSchema, objectName, remoteSource = null) {
+    this._isVirtual = true;
+    this._virtualObjectSchema = objectSchema;
+    this._virtualObjectName = objectName;
+    this._remoteSource = remoteSource;
+};
 
 function mergeAdmindataTuples(into, data) {
     for (const tuple of data) {

package/lib/model/metadataReader.js

@@ -44,11 +44,15 @@ function loadKeysForTable(context, entityType, cb) {
         return cb(null, entityType);
     };
 
-    var schema = entityType.schema || context.defaultSchema;
-
-    var sql =
-        "SELECT * from CONSTRAINTS " +
-        "WHERE SCHEMA_NAME = '" + schema + "' AND TABLE_NAME = '" + entityType.tableName + "' AND IS_PRIMARY_KEY = 'TRUE' ORDER BY position";
+    let sql = "";
+    if (entityType._isVirtual) {
+        sql =
+            "select * from " + (entityType._remoteSource ? "\"" + entityType._remoteSource + "\".\"SYS\".\"CONSTRAINTS\"" : "\"SYS\".\"CONSTRAINTS\" " ) +
+            "WHERE SCHEMA_NAME = '" + entityType._virtualObjectSchema + "' AND TABLE_NAME = '" + entityType._virtualObjectName + "' AND IS_PRIMARY_KEY = 'TRUE' ORDER BY position";
+    } else {
+        let schema = entityType.schema || context.defaultSchema;
+        sql = "SELECT * from CONSTRAINTS WHERE SCHEMA_NAME = '" + schema + "' AND TABLE_NAME = '" + entityType.tableName + "' AND IS_PRIMARY_KEY = 'TRUE' ORDER BY position";
+    }
     dataCollector2.executeSqlDirectly(context, sql, processRows);
 }
 
@@ -104,13 +108,13 @@ function loadTableInfo(context, entityType, tableStoreType, cb) {
         }
     };
 
-    context.logger.silly("model", "loadTableInfo 2");
-    var schema = entityType.schema || context.defaultSchema;
-    // entityType.table is either a real table or a SQL view
-    // So we need to lookup both: sys.table_columns and sys.view_columns
-    // sys.columns is not usable due to access restrictions
-    var sql =
+    let schema = "";
+    let parameters = [];
 
+    // entityType.table is either a real table or a SQL view;
+    // so we need to lookup both: sys.table_columns and sys.view_columns (if set: check via "remote source");
+    // sys.columns is not usable due to access restrictions
+    let sql =
         "SELECT " +
         "   TO_BIGINT(" + model.entityKind.table + ") kind, " +
         "   table_name, " +
@@ -121,7 +125,7 @@ function loadTableInfo(context, entityType, tableStoreType, cb) {
         "   length, " +
         "   scale, " +
         "   default_value " +
-        "FROM TABLE_COLUMNS " +
+        "FROM " + (entityType._remoteSource ? "\"" + entityType._remoteSource + "\"" + ".\"SYS\".\"TABLE_COLUMNS\"" : "TABLE_COLUMNS ") +
         "WHERE  schema_name = ? AND " +
         "       table_name = ? " +
         "UNION ALL " +
@@ -135,13 +139,17 @@ function loadTableInfo(context, entityType, tableStoreType, cb) {
         "   length, " +
         "   scale, " +
         "   default_value " +
-        "FROM VIEW_COLUMNS " +
+        "FROM " + (entityType._remoteSource ? "\"" + entityType._remoteSource + "\"" + ".\"SYS\".\"VIEW_COLUMNS\"" : "VIEW_COLUMNS ") +
         "WHERE  schema_name = ? AND " +
         "       view_name = ?  " +
         "ORDER BY position";
 
-    var parameters = [schema, entityType.tableName, schema, entityType.tableName];
-
+    if (entityType._isVirtual) {
+        parameters = [entityType._virtualObjectSchema, entityType._virtualObjectName, entityType._virtualObjectSchema, entityType._virtualObjectName];
+    } else {
+        schema = entityType.schema || context.defaultSchema;
+        parameters = [schema, entityType.tableName, schema, entityType.tableName];
+    }
     context.logger.silly("model", "sql loadTableInfo: " + sql);
     context.logger.silly("model", "sql parameters: " + parameters);
     dataCollector2.executeSqlAsPreparedStatement(context, sql, parameters, processRows);
@@ -151,26 +159,26 @@ function loadCalcViewInfo(context, entityType, cb) {
     /*
      Remark : it is not possible(or at least i was not able to) to execute a JOIN in a MDX SELECT
      */
-    var schema = entityType.schema || context.defaultSchema;
-    var sql = 'select ' +
-        'SCHEMA_NAME,' +
-        'QUALIFIED_NAME,' +
-        'CATALOG_NAME,' +
-        'CUBE_NAME,' +
-        'COLUMN_NAME,' +           // JOIN ON
-        'MEASURE_AGGREGATOR,' +    // 1, 2, 3, 4 in sync with entityType.CV_AGGREGATE_FUNCTIONS
-        'MEASURE_AGGREGATABLE, ' +
-        'SEMANTIC_TYPE, ' +
-        'COLUMN_CAPTION, ' +
-        'DIMENSION_TYPE, ' +
-        'UNIT_COLUMN_NAME, ' +
-        'DESC_NAME, ' +
-        '"ORDER" ' +
-        "from _SYS_BI.BIMC_DIMENSION_VIEW_HDI " +
+    let schema = entityType.schema || context.defaultSchema;
+    let sql =
+        'select ' +
+            'SCHEMA_NAME,' +
+            'QUALIFIED_NAME,' +
+            'CATALOG_NAME,' +
+            'CUBE_NAME,' +
+            'COLUMN_NAME,' +           // JOIN ON
+            'MEASURE_AGGREGATOR,' +    // 1, 2, 3, 4, 5 in sync with entityType.CV_AGGREGATE_FUNCTIONS
+            'MEASURE_AGGREGATABLE, ' +
+            'SEMANTIC_TYPE, ' +
+            'COLUMN_CAPTION, ' +
+            'DIMENSION_TYPE, ' +
+            'UNIT_COLUMN_NAME, ' +
+            'DESC_NAME, ' +
+            '"ORDER" ' +
+        "from " + (entityType._remoteSource ? "\"" + entityType._remoteSource + "\"" + ".\"_SYS_BI\".\"BIMC_DIMENSION_VIEW_HDI\"" : "_SYS_BI.BIMC_DIMENSION_VIEW_HDI ") +
         "where SCHEMA_NAME = ? AND QUALIFIED_NAME = ? " +
         'order by "ORDER"';
 
-
     function processRows(err, rows) {
         if (logMetadata) {
             context.logger.silly('metadataReader', 'rows\n' + JSON.stringify(rows, null, 4));
@@ -232,27 +240,37 @@ function loadCalcViewInfo(context, entityType, cb) {
      The current HANA version has a bug, and prepared statements are not working in mdx select.
      Hence i replaced prepared statement with direct sql statement.
     */
-    var parameters = [schema, entityType.tableName];
+
+    let parameters = [];
+    if (entityType._isVirtual) {
+        // CV information must be read from the remote database;
+        // no such concept of "virtual" CV data in local database as it is the case for tables
+        parameters = [entityType._virtualObjectSchema, entityType._virtualObjectName];
+    } else {
+        parameters = [schema, entityType.tableName];
+    }
     dataCollector2.executeSqlAsPreparedStatement(context, sql, parameters, processRows);
 }
 
 function loadInputParameters(parameters, entityType, context, cb) {
-    // At the time this sql was developed SCHEMA_NAME == NULL
-    var sql = 'select distinct ' +
-        'VARIABLE_NAME, ' +
-        'COLUMN_TYPE_D, ' +
-        'COLUMN_SQL_TYPE, ' +
-        'MANDATORY, ' +
-        'DESCRIPTION, ' +
-        'DEFAULT_VALUE, ' +
-        'SEMANTIC_TYPE, ' +
-        'SELECTION_TYPE, ' +
-        'MULTILINE, ' +
-        '"ORDER" ' +
-        'from _SYS_BI.BIMC_VARIABLE_VIEW_HDI where QUALIFIED_NAME = ? order by "ORDER"';
+
+    let sql =
+        'select distinct ' +
+            'VARIABLE_NAME, ' +
+            'COLUMN_TYPE_D, ' +
+            'COLUMN_SQL_TYPE, ' +
+            'MANDATORY, ' +
+            'DESCRIPTION, ' +
+            'DEFAULT_VALUE, ' +
+            'SEMANTIC_TYPE, ' +
+            'SELECTION_TYPE, ' +
+            'MULTILINE, ' +
+            '"ORDER" ' +
+        'from ' + (entityType._remoteSource ? '"' + entityType._remoteSource + '"' + '"_SYS_BI"."BIMC_VARIABLE_VIEW_HDI"' : '_SYS_BI.BIMC_VARIABLE_VIEW_HDI ') +
+        'where QUALIFIED_NAME = ? order by "ORDER"';
 
     context.logger.debug('metadataReader', 'loadInputParameters: ' + entityType.tableName);
-    context.logger.silly("metadataReader", "sql loadInputParameters: " + sql);
+    context.logger.debug("metadataReader", "sql loadInputParameters: " + sql);
 
     dataCollector2.executeSqlAsPreparedStatement(context, sql, [entityType.tableName], (err, rows) => {
 
@@ -459,17 +477,127 @@ function loadEntityType(context, entityType, cbErr) {
  * @param {Function} callback - callback function, which is called when the operation is completed.
  */
 function determineStoreType(context, entityType, callback) {
-    var schema = entityType.schema || context.defaultSchema,
+
+    let schema = entityType.schema || context.defaultSchema,
         sql = 'select IS_COLUMN_TABLE as "IS_COLUMN_TYPE" from TABLES where SCHEMA_NAME = ? AND TABLE_NAME = ? ' +
-            'union select IS_COLUMN_VIEW as "IS_COLUMN_TYPE" from VIEWS where SCHEMA_NAME = ? AND VIEW_NAME = ?',
+              'union select IS_COLUMN_VIEW as "IS_COLUMN_TYPE" from VIEWS where SCHEMA_NAME = ? AND VIEW_NAME = ?',
         tableName = entityType.tableName,
         parameters = [schema, tableName, schema, tableName];
 
-    context.logger.silly("model", "sql determineStoreType: " + sql);
-    context.logger.silly("model", "sql determineStoreType parameters: " + parameters);
+    context.logger.debug("model", "sql determineStoreType: " + sql);
+    context.logger.debug("model", "sql determineStoreType parameters: " + parameters);
 
     dataCollector2.executeSqlAsPreparedStatement(context, sql, parameters, (error, rows) => {
-        return processTableType(error, rows, context, tableName, callback);
+
+        if (error) {
+            return callback(new SqlError(context, error));
+        }
+
+        // if no error and no rows are returned: check for public synonym;
+        // if a virtual table is used (includes remote tables and remote views / CVs), we got a row back here!
+        if (rows.length === 0) {
+            context.logger.debug("model", `No table/view information found for ${tableName}. Try public synonym.`);
+            processSynonymTableType(context, entityType, tableName, (synonymErr, synonymFound, tableStoreType) => {
+                if (synonymErr) {
+                    return callback(synonymErr);
+                }
+                if (synonymFound) {
+                    return callback(null, tableStoreType);
+                }
+                return callback(new NotFound(`No table/view or synonym data found for table ${tableName}.`, context));
+            });
+        } else {
+            // check for virtual table; add VT data for entity type, if existing
+            let virtualTableSQL = "select * from SYS.VIRTUAL_TABLES where schema_name = ? and table_name = ?";
+            let virtualTableParameters = [schema, tableName];
+            context.logger.info("model", `Check for virtual table for ${tableName}`);
+            dataCollector2.executeSqlAsPreparedStatement(context, virtualTableSQL, virtualTableParameters, (sqlError, virtualTableRows) => {
+                if (sqlError) {
+                    context.logger.error("model", `Failed read data for virtual table: ${tableName}` + sqlError);
+                    return callback(new SqlError(context, sqlError));
+                }
+                if (virtualTableRows.length !== 0) {
+                    entityType.setVirtualInfo(
+                        virtualTableRows[0].REMOTE_OWNER_NAME,
+                        virtualTableRows[0].REMOTE_OBJECT_NAME,
+                        virtualTableRows[0].REMOTE_SOURCE_NAME );
+                    context.logger.info("model", `(Remote) Virtual table information for table ${tableName}`);
+                    context.logger.info("model", `Remote schema: ${virtualTableRows[0].REMOTE_OWNER_NAME}`);
+                    context.logger.info("model", `Remote object: ${virtualTableRows[0].REMOTE_OBJECT_NAME}`);
+                    context.logger.info("model", `Remote source: ${virtualTableRows[0].REMOTE_SOURCE_NAME}`);
+                } else {
+                    context.logger.info("model", `No virtual table information exists for ${tableName}`);
+                }
+                // use data already found from TABLES / VIEWS for setting store type
+                return processTableType(error, rows, context, tableName, callback);
+            });
+        }
+    });
+}
+
+function processSynonymTableType(context, entityType, tableName, callback) {
+
+    const synonymSql = `select * from SYNONYMS where SCHEMA_NAME = 'PUBLIC' AND SYNONYM_NAME = '${tableName}'`;
+
+    dataCollector2.executeSqlDirectly(context, synonymSql, (synonymErr, synonymRows) => {
+        if (synonymErr) {
+            context.logger.error("model", "Failed to read synonym: " + synonymErr);
+            return callback(new SqlError(context, synonymErr), false, null);
+        }
+        if (synonymRows.length === 0) {
+            return callback(null, false, null);     // not a synonym
+        }
+        if (synonymRows.length !== 1) {
+            context.logger.error("model", "No (unique) synonym data found for " + tableName + " table.");
+            return callback(new NotFound("No (unique) synonym data found for " + tableName + " table.", context), false, null);
+        }
+
+        // check for local or remote synonym
+        if (synonymRows[0].OBJECT_SCHEMA === '_SYS_LDB') {      // remote synonym
+
+            const virtualTableName = synonymRows[0].OBJECT_NAME;
+            const virtualTableSql = `select * from VIRTUAL_TABLES where SCHEMA_NAME = '_SYS_LDB' and TABLE_NAME = '${virtualTableName}'`;
+
+            context.logger.info("model", `Checking virtual tables for remote synonym information for table ${virtualTableName}`);
+
+            // get remote source
+            dataCollector2.executeSqlDirectly(context, virtualTableSql, (virtualTableErr, virtualTableRows) => {
+                if (virtualTableErr) {
+                    context.logger.error("model", `Failed to read virtual table ${virtualTableName} for synonym ${tableName}:  ${virtualTableErr}`);
+                    return callback(new SqlError(context, virtualTableErr), false, null);
+                }
+
+                context.logger.info("model", `(Remote) Virtual table information for synonym ${tableName} via table ${virtualTableName}`);
+                context.logger.info("model", `Remote schema: ${virtualTableRows[0].REMOTE_OWNER_NAME}`);
+                context.logger.info("model", `Remote object: ${virtualTableRows[0].REMOTE_OBJECT_NAME}`);
+                context.logger.info("model", `Remote source: ${virtualTableRows[0].REMOTE_SOURCE_NAME}`);
+
+                entityType.setVirtualInfo(
+                    virtualTableRows[0].REMOTE_OWNER_NAME,      // remote schema name
+                    virtualTableRows[0].REMOTE_OBJECT_NAME,     // remote object name
+                    virtualTableRows[0].REMOTE_SOURCE_NAME);    // remote source
+
+                // in SYNONYMS, each remote object has always the setting IS_COLUMN_OBJECT === FALSE (keep it as is)
+                let isColumnStoreType = synonymRows[0].IS_COLUMN_OBJECT;
+                let tableStoreType = isColumnStoreType === "TRUE" ? "column" : "row";
+                return callback(null, true, tableStoreType);
+            });
+
+        } else {    // local synonym
+
+            context.logger.info("model", `(Local) Synonym information for ${synonymRows[0].SYNONYM_NAME}`);
+            context.logger.info("model", `Local schema: ${synonymRows[0].OBJECT_SCHEMA}`);
+            context.logger.info("model", `Local object: ${synonymRows[0].OBJECT_NAME}`);
+
+            entityType.setVirtualInfo(
+                synonymRows[0].OBJECT_SCHEMA,       // local schema name
+                synonymRows[0].OBJECT_NAME);        // local object name
+
+            // in SYNONYMS, a local object has the "correct" store type setting
+            let isColumnObjectType = synonymRows[0].IS_COLUMN_OBJECT;
+            let tableStoreType = isColumnObjectType === "TRUE" ? "column" : "row";
+            return callback(null, true, tableStoreType);
+        }
     });
 }
 
@@ -487,7 +615,7 @@ function processTableType(error, dbRows, context, tableName, callback) {
         tableStoreType;
 
     if (error) {
-        return callback(new SqlError(context, error));
+        return (error instanceof SqlError) ? callback(error) : callback(new SqlError(context, error));
     }
 
     if (dbRows.length === 0) {
@@ -497,6 +625,8 @@ function processTableType(error, dbRows, context, tableName, callback) {
         context.logger.silly("processTableType", "rows:\n" + JSON.stringify(dbRows, null, 4));
     }
 
+    // if found table is a virtual (remote) table, the IS_COLUMN_TYPE is always set to FALSE,
+    // but this setting does not affect SQL processing (joins on temp. tables)
     isColumnStoreType = dbRows[0].IS_COLUMN_TYPE;
 
     // HANA returns "TRUE"/"FALSE" as a string and not as a boolean value
@@ -592,6 +722,9 @@ exports.loadModelMetadata = function (context, asyncDone) {
             }
         },
         function (err) {
+            if (err) {
+                context.logger.error('model', `Error on loadEntityTypes for ${context.uriTree.xsoFile}:` + err);
+            }
             context.logger.silly('model', 'loadEntityTypes finished for ' + context.uriTree.xsoFile);
             return asyncDone(err, context);
         }

package/lib/model/xsodataReader.js

@@ -182,7 +182,7 @@ function checkSchema(context, asyncDone) {
     entityTypes = parsedXsodata.service.entityTypes;
 
 
-    // Run through entityTypes and check if navigates peroperty id provided
+    // Run through entityTypes and check if navigates property id provided
     for (key in entityTypes) {
         if (entityTypes.hasOwnProperty(key) === true) {
 

package/lib/processor/batchProcessor.js

@@ -148,15 +148,15 @@ function processChangeSet(batchContext, part, asyncDone) {
 
             utils.try(collectContentIds),
 
-            utils.try(processChangeSetPartsCreateTable),
+            utils.try(processChangeSetPartsCreateTable),    // for *ALL* operations of current changeset: create all temp. tables once at beginning
 
-            utils.try(processChangeSetParts),
+            utils.try(processChangeSetParts),               // execute all operations
 
-            utils.try(processChangeSetPartsPreCommit),
+            utils.try(processChangeSetPartsPreCommit),      // mainly custom-exit processing (pre-commit exit)
 
-            utils.try(processChangeSetPartsCommit),
+            utils.try(processChangeSetPartsCommit),         // all changes of operations are committed
 
-            utils.try(processChangeSetPartsPostCommit)
+            utils.try(processChangeSetPartsPostCommit)      // mainly custom-exit processing (post-commit exit)
 
         ], function (err, batchContext) {
             if (!err) {
@@ -220,7 +220,7 @@ function processAppWithState(app, state, batchContext, asyncDone) {
 
 function processPart(batchContext, part, asyncDone) {
     batchContext.logger.silly('batchProcessor', 'processPart');
-    if (part.type === 'app') {
+    if (part.type === 'app') {                      // processing a batch single operation (not in changeset)
         async.waterfall(
             [
                 utils.injectContext(batchContext),
@@ -288,7 +288,7 @@ exports.process = function (context, asyncDone) {
     var batchContext = {
         parentContext: context,
         logger: context.logger,
-        callRegisteredStep : context.callRegisteredStep, // pass to inner context
+        callRegisteredStep : context.callRegisteredStep,    // pass to inner context
         inChangeSet: false,
         batchData: null,
         batchParsed: null,

package/lib/processor/processor.js

@@ -21,15 +21,15 @@ exports.processRequest = function (context, asyncDone) {
         } else if (oData.kind === odataUri.URI_KIND_MetaData) {
             Measurement.measureWithCB(metadataProcessor.process, context, asyncDone, 'metadataProcessor.process');
         } else if (oData.kind === odataUri.URI_KIND_Batch) {
-            Measurement.measureWithCB(batchProcessor.process, context, asyncDone, 'batchProcessor.process');
+            Measurement.measureWithCB(batchProcessor.process, context, asyncDone, 'batchProcessor.process');        // $batch-request itself
         } else if (oData.kind === odataUri.URI_KIND_Resource) {
 
             if (!context.batchContext) {
-                //normal no batch request processing
+                // regular request processing
                 Measurement.measureWithCB(resourceProcessor.process, context, asyncDone, 'resourceProcessor.process');
             } else {
-                var batchContext = context.batchContext;
-                if (batchContext.status === batchRunState.createTables) {
+                var batchContext = context.batchContext;                            // $batch-request: operation processing (based on status)
+                if (batchContext.status === batchRunState.createTables) {           // on batch changes: all temp. tables of all operations are generated at beginning batch
                     Measurement.measureWithCB(resourceProcessor.processInBatchCreateTables, context, asyncDone, 'processInBatchCreateTables');
                 }else if (batchContext.status === batchRunState.execution) {
                     Measurement.measureWithCB(resourceProcessor.processInBatch, context, asyncDone, 'processInBatch');