in temporary Context_lib-function: added possibility of overwriting a columns table-alias

process/Context_lib/process.js

@@ -195,11 +195,22 @@ ContextSelector.create = function(pTableName, pIdField, pTitleExpression)
     return new ContextSelector(pTableName, pIdField, pTitleExpression);
 };
 /**
- * @return {String} full id field containing tablename and column
+ * @param {String} pField the fieldname that shall be returned as full string
+ * @return {String} full field containing tablename and the column; if the column itself is already a full qualified field that field is returned
+ */
+ContextSelector.prototype.getFullField = function(pField)
+{
+    if (SqlUtils.isFullFieldQualifier(pField))
+        return pField;
+    else
+        return this.tableName + "." + pField;
+};
+/**
+ * @return {String} full id field containing tablename and column; if the column itself is already a full qualified field that field is returned
  */
 ContextSelector.prototype.getFullIdField = function()
 {
-    return this.tableName + "." + this.idField;
+    return this.getFullField(this.idField);
 };
 /**
  * @return {String} full from-expression with tablename and join-part
@@ -347,7 +358,7 @@ ContextUtils.getNameSubselectSql = function(pContextIdDbField, pRowIdDbField)
     var selectMap = ContextUtils.getSelectMap ()
     for (let contextId in selectMap)
     {
-        select += "when '" + contextId + "' then (select " + selectMap[contextId].titleExpression + " from " + selectMap[contextId].getFullFromClause() + (pRowIdDbField ? " where " + selectMap[contextId].idField + " = " + pRowIdDbField : " ") + ") ";
+        select += "when '" + contextId + "' then (select " + selectMap[contextId].titleExpression + " from " + selectMap[contextId].getFullFromClause() + (pRowIdDbField ? " where " + selectMap[pContextId].getFullIdField() + " = " + pRowIdDbField : " ") + ") ";
     }
 
     select += "else 'Not defined in ContextUtils.getNameSql()!'";
@@ -382,7 +393,7 @@ ContextUtils.getContextDataSql = function(pContextId, pContactId, pWithDate, pAc
     var cond = SqlCondition.begin();
     if (pContactId)
     {
-        cond.andPrepare(ownContextSelector.tableName + "." + ownContextSelector.contactIdField, pContactId)
+        cond.andPrepare(ownContextSelector.getFullField(ownContextSelector.contactIdField), pContactId)
     }
     
     if (pActive != undefined)
@@ -408,7 +419,7 @@ ContextUtils.getContextDataSql = function(pContextId, pContactId, pWithDate, pAc
         
         pExcludedObjectIds.forEach(function(id)
         {
-            this.andPrepare(ownContextSelector.tableName + "." + ownContextSelector.idField, id, "# <> ?");
+            this.andPrepare(ownContextSelector.getFullIdField(), id, "# <> ?");
         }, exludedIdsCond)
         
         cond.andSqlCondition(exludedIdsCond);

process/Sql_lib/process.js

@@ -1033,42 +1033,129 @@ SqlMaskingUtils.prototype.yearFromDate = function(pField)
     return retSql;
 }
 
+/**
+ * functions for various Sql-actions
+ * Do not create an instance of this!
+ *
+ * @class
+ * @static
+ */
 function SqlUtils() {}
 
-SqlUtils.getSingleColumnType = function(fieldOrTableName, columnName, alias) {
-    var tableName, fieldVarType;
-    if (columnName == undefined){
-        fieldVarType = typeof(fieldOrTableName);
-        if (fieldVarType == "string") {
-            fieldOrTableName = text.split(fieldOrTableName, "\\.");
-        } else if (fieldVarType != "object") {
-            throw new TypeError(translate.text("${SQL_LIB_WRONG_FIELD_TYPE}"));
+/**
+* parses given name of table and name of column to clearly find out the tablename and columnanme
+*
+* @param {String|Array} pFieldOrTableName you've got several possibilites to pass here:
+*                                   <br/> 1. the name of the table if also a pColumnName is specified 
+*                                   <br/> 2. the name of the table and columname as "tablename.columnname" (e.g. "ORGANISATION.NAME") if no pColumnName is specified
+*                                   <br/> 3. an array with 2 elements: [tablename, columnname] (e.g. ["ORGANISATION", "NAME"]) if no pColumnName is specified
+*                                   <br/> Everything else will raise an error
+*                                   
+* @param {String} [pColumnName] depending on pFieldOrTableName this should be undefined/null or the name of a column
+*
+* @return {Object|TypeError} TypeError if something wrong has been passed or returns a object with these properties: 
+*                           1. "table" which is the tablename
+*                           2. "column" which is the columnname
+*                           e.g. {table: "ORGANISATION", column: "NAME"}
+* 
+*
+*/
+SqlUtils._parseFieldQualifier = function(pFieldOrTableName, pColumnName) 
+{
+    var tableName, columnName;
+    if (pColumnName != undefined)
+    {
+        tableName = pFieldOrTableName;
+        columnName = pColumnName;
+    }
+    else
+    {
+        var fnName = "SqlUtils._parseFieldQualifier";//for return errors
+        var fieldVarType = typeof(pFieldOrTableName);
+        if (fieldVarType == "string") 
+        {
+            pFieldOrTableName = text.split(pFieldOrTableName, "\\.");
+        }
+        else if (fieldVarType != "object") //check for object since there exists JavaArrays and JavaScript arrays which are both valid
+        {
+            return new TypeError(translate.withArguments("[%0]%1 has to be a string or array but it is %2", [fnName, "pFieldOrTableName",
+                fieldVarType]));
         }
 
-        if (fieldOrTableName.hasOwnProperty("length")) {
-            if (fieldOrTableName.length == 2) {
+        if (pFieldOrTableName.hasOwnProperty("length")) 
+        {
+            if (pFieldOrTableName.length != 2) 
+                return new TypeError(translate.withArguments("[%0]has now an incorrect length; estimated 2 elements but got %1", [
+                        fnName, pFieldOrTableName.length ]));
 
-            } else {
-                throw new TypeError(translate.text("${SQL_LIB_WRONG_FIELD_TYPE}"))
-            }
-            tableName = fieldOrTableName[0];
-            columnName = fieldOrTableName[1];
+            tableName = pFieldOrTableName[0];
+            columnName = pFieldOrTableName[1];
         }
-        else
-            throw new TypeError(translate.text("${SQL_LIB_WRONG_FIELD_TYPE}"));
+        else //check for object happens since there exists JavaArrays and JavaScript arrays which are both valid
+            return  new TypeError(translate.withArguments("[%0]%1 is an object but seems not to be a valid array or array-like", [
+                    fnName, "pFieldOrTableName"]));
     }
-    else
-        tableName = fieldOrTableName;
 
     if (typeof(columnName) != "string")
-        throw new TypeError(translate.text("${SQL_LIB_WRONG_FIELD_TYPE}"));
+        return  new TypeError(translate.withArguments("[%0]the columnName is not a string after interpreting", [fnName]));
     if (typeof(tableName) != "string")
-        throw new TypeError(translate.text("${SQL_LIB_WRONG_FIELD_TYPE}"));
+        return  new TypeError(translate.withArguments("[%0]the tableName is not a string after interpreting", [fnName]));
 
-    if (alias == undefined)
-        alias = db.getCurrentAlias();
+    return {
+        table: tableName,
+        column: columnName
+    };
+};
+
+
+/**
+* determines if given values match a full field qualifier (name of table and name of column)
+*
+* @param {String|Array} pFieldOrTableName you've got several possibilites to pass here:
+*                                   <br/> 1. the name of the table if also a pColumnName is specified 
+*                                   <br/> 2. the name of the table and columname as "tablename.columnname" (e.g. "ORGANISATION.NAME") if no pColumnName is specified
+*                                   <br/> 3. an array with 2 elements: [tablename, columnname] (e.g. ["ORGANISATION", "NAME"]) if no pColumnName is specified
+*                                   <br/> Everything else will raise an error
+*                                   
+* @param {String} [pColumnName] depending on pFieldOrTableName this should be undefined/null or the name of a column
+*
+* @return {Boolean} returns true if it's a full qualifier or false if not
+*
+*/
+SqlUtils.isFullFieldQualifier = function(pFieldOrTableName, pColumnName)
+{
+    var parsed = SqlUtils._parseFieldQualifier(pFieldOrTableName, pColumnName);
+    if (parsed instanceof TypeError)
+        return false;
+    return true;
+};
+
+/**
+* determines the type of a single database column in a table; if you want to  get several columntypes at once use db.getColumnTypes instead 
+*
+* @param {String|Array} pFieldOrTableName you've got several possibilites to pass here:
+*                                   <br/> 1. the name of the table if also a pColumnName is specified 
+*                                   <br/> 2. the name of the table and columname as "tablename.columnname" (e.g. "ORGANISATION.NAME") if no pColumnName is specified
+*                                   <br/> 3. an array with 2 elements: [tablename, columnname] (e.g. ["ORGANISATION", "NAME"]) if no pColumnName is specified
+*                                   <br/> Everything else will raise an error
+*                                   
+* @param {String} [pColumnName] depending on pFieldOrTableName this should be undefined/null or the name of a column
+* @param {String} [pAlias=the current alias] Database-Aliasname, where the SQL-Statement shall be executed; default is the current dbalias
+*
+* @throws TypeError if a wrong format is passed as table/column-combination
+*
+* @return {Number} returns the corresponding SQLTYPES-value
+*
+*/
+SqlUtils.getSingleColumnType = function(pFieldOrTableName, pColumnName, pAlias) {
+    var fields = SqlUtils._parseFieldQualifier(pFieldOrTableName, pColumnName);
+    if (fields instanceof TypeError)
+        throw fields;
+    
+    if (pAlias == undefined)
+        pAlias = db.getCurrentAlias();
 
-    return db.getColumnTypes(tableName, [columnName], alias)[0];
+    return db.getColumnTypes(fields.table, [fields.column], pAlias)[0];
 };
 
 /**