Augment the function call map logic with code from Tom Lane.

 Should be more robust to overflows.
 Pass through an unmapped function unchanged, rather than rejecting it.
Add a few more functions, but comment out those which can go through as-is.
Can be used with contrib/odbc/ package, though that isn't committed yet.

diff --git a/src/interfaces/odbc/convert.c b/src/interfaces/odbc/convert.c
index 24906e10ff4cdebc14a6cf38c20a72ef8ed97383..f87b91577997816489aa552a94e435eee1093159 100644 (file)
--- a/src/interfaces/odbc/convert.c
+++ b/src/interfaces/odbc/convert.c
@@ -58,19 +58,76 @@ typedef signed char SCHAR;
 
 extern GLOBAL_VALUES globals;
 
-/* How to map ODBC scalar functions {fn func(args)} to Postgres */
-/* This is just a simple substitution */
-char *mapFuncs[][2] = {   
-   { "CONCAT",      "textcat" },
-   { "LCASE",       "lower"   },
-   { "LOCATE",      "strpos"  },
-   { "LENGTH",      "textlen" },
-   { "LTRIM",       "ltrim"   },
-   { "RTRIM",       "rtrim"   },
-   { "SUBSTRING",   "substr"  },
-   { "UCASE",       "upper"   },
-   { "NOW",         "now"     },
-   {    0,             0      }
+/* How to map ODBC scalar functions {fn func(args)} to Postgres
+ * This is just a simple substitution
+ * List augmented from
+ *  http://www.merant.com/datadirect/download/docs/odbc16/Odbcref/rappc.htm
+ * - thomas 2000-04-03
+ */
+char *mapFuncs[][2] = {
+// { "ASCII",       "ascii"      },
+   { "CHAR",        "ichar"      },
+   { "CONCAT",      "textcat"    },
+// { "DIFFERENCE",  "difference" },
+// { "INSERT",      "insert"     },
+   { "LCASE",       "lower"      },
+   { "LEFT",        "ltrunc"     },
+   { "LOCATE",      "strpos"     },
+   { "LENGTH",      "char_length"},
+// { "LTRIM",       "ltrim"      },
+   { "RIGHT",       "rtrunc"     },
+// { "REPEAT",      "repeat"     },
+// { "REPLACE",     "replace"    },
+// { "RTRIM",       "rtrim"      },
+// { "SOUNDEX",     "soundex"    },
+   { "SUBSTRING",   "substr"     },
+   { "UCASE",       "upper"      },
+
+// { "ABS",         "abs"        },
+// { "ACOS",        "acos"       },
+// { "ASIN",        "asin"       },
+// { "ATAN",        "atan"       },
+// { "ATAN2",       "atan2"      },
+   { "CEILING",     "ceil"       },
+// { "COS",         "cos"        },
+// { "COT",         "cot"        },
+// { "DEGREES",     "degrees"    },
+// { "EXP",         "exp"        },
+// { "FLOOR",       "floor"      },
+   { "LOG",         "ln"         },
+   { "LOG10",       "log"        },
+// { "MOD",         "mod"        },
+// { "PI",          "pi"         },
+   { "POWER",       "pow"        },
+// { "RADIANS",     "radians"    },
+   { "RAND",        "random"     },
+// { "ROUND",       "round"      },
+// { "SIGN",        "sign"       },
+// { "SIN",         "sin"        },
+// { "SQRT",        "sqrt"       },
+// { "TAN",         "tan"        },
+// { "TRUNCATE",    "truncate"   },
+
+// { "CURDATE",     "curdate"    },
+// { "CURTIME",     "curtime"    },
+// { "DAYNAME",     "dayname"    },
+// { "DAYOFMONTH",  "dayofmonth" },
+// { "DAYOFWEEK",   "dayofweek"  },
+// { "DAYOFYEAR",   "dayofyear"  },
+// { "HOUR",        "hour"       },
+// { "MINUTE",      "minute"     },
+// { "MONTH",       "month"      },
+// { "MONTHNAME",   "monthname"  },
+// { "NOW",         "now"        },
+// { "QUARTER",     "quarter"    },
+// { "SECOND",      "second"     },
+// { "WEEK",        "week"       },
+// { "YEAR",        "year"       },
+
+// { "DATABASE",    "database"   },
+   { "IFNULL",      "coalesce"   },
+   { "USER",        "odbc_user"  },
+   {    0,             0         }
 };
 
 char *mapFunction(char *func);
@@ -584,7 +641,7 @@ int
 copy_statement_with_parameters(StatementClass *stmt)
 {
 static char *func="copy_statement_with_parameters";
-unsigned int opos, npos;
+unsigned int opos, npos, oldstmtlen;
 char param_string[128], tmp[256], cbuf[TEXT_FIELD_SIZE+5];
 int param_number;
 Int2 param_ctype, param_sqltype;
@@ -629,14 +686,17 @@ int lobj_fd, retval;
 
     param_number = -1;
 
-    for (opos = 0; opos < strlen(old_statement); opos++) {
+   oldstmtlen = strlen(old_statement);
+
+    for (opos = 0; opos <  oldstmtlen; opos++) {
 
        //  Squeeze carriage-returns/linfeed pairs to linefeed only
-       if (old_statement[opos] == '\r' && opos+1<strlen(old_statement) && old_statement[opos+1] == '\n') {
+       if (old_statement[opos] == '\r' && opos+1 < oldstmtlen &&
+           old_statement[opos+1] == '\n') {
            continue;
        }
 
-       //  Handle literals (date, time, timestamp)
+       //  Handle literals (date, time, timestamp) and ODBC scalar functions
        else if (old_statement[opos] == '{') {
            char *esc;
            char *begin = &old_statement[opos + 1];
@@ -1056,37 +1116,69 @@ int i;
    return NULL;
 }
 
-// This function returns a pointer to static memory!
+/* convert_escape()
+ * This function returns a pointer to static memory!
+ */
 char *
 convert_escape(char *value)
 {
-char key[32], val[256];
 static char escape[1024];
-char func[32], the_rest[1024];
-char *mapFunc;
-
-   sscanf(value, "%s %[^\r]", key, val);
+char key[33];
 
-   mylog("convert_escape: key='%s', val='%s'\n", key, val);
+   /* Separate off the key, skipping leading and trailing whitespace */
+   while ((*value != '\0') && isspace(*value)) value++;
+   sscanf(value, "%32s", key);
+   while ((*value != '\0') && (! isspace(*value))) value++;
+   while ((*value != '\0') && isspace(*value)) value++;
 
-   if ( ! strcmp(key, "d") ||
-        ! strcmp(key, "t") ||
-        ! strcmp(key, "ts")) {
+   mylog("convert_escape: key='%s', val='%s'\n", key, value);
 
-       strcpy(escape, val);
+   if ( (strcmp(key, "d") == 0) ||
+        (strcmp(key, "t") == 0) ||
+        (strcmp(key, "ts") == 0)) {
+       /* Literal; return the escape part as-is */
+       strncpy(escape, value, sizeof(escape)-1);
    }
-   else if ( ! strcmp(key, "fn")) {
-       sscanf(val, "%[^(]%[^\r]", func, the_rest);
-       mapFunc = mapFunction(func);
-       if ( ! mapFunc)
-           return NULL;
-       else {
-           strcpy(escape, mapFunc);
-           strcat(escape, the_rest);
+   else if (strcmp(key, "fn") == 0) {
+       /* Function invocation
+        * Separate off the func name,
+        * skipping trailing whitespace.
+        */
+       char *funcEnd = value;
+       char svchar;
+       char *mapFunc;
+
+       while ((*funcEnd != '\0') && (*funcEnd != '(') &&
+              (! isspace(*funcEnd))) funcEnd++;
+       svchar = *funcEnd;
+       *funcEnd = '\0';
+       sscanf(value, "%32s", key);
+       *funcEnd = svchar;
+       while ((*funcEnd != '\0') && isspace(*funcEnd)) funcEnd++;
+
+       /* We expect left parenthensis here,
+        * else return fn body as-is since it is
+        * one of those "function constants".
+        */
+       if (*funcEnd != '(') {
+           strncpy(escape, value, sizeof(escape)-1);
+           return escape;
        }
-
+       mapFunc = mapFunction(key);
+       /* We could have mapFunction() return key if not in table...
+        * - thomas 2000-04-03
+        */
+       if (mapFunc == NULL) {
+           /* If unrecognized function name, return fn body as-is */
+           strncpy(escape, value, sizeof(escape)-1);
+           return escape;
+       }
+       /* copy mapped name and remaining input string */
+       strcpy(escape, mapFunc);
+       strncat(escape, funcEnd, sizeof(escape)-strlen(mapFunc));
    }
    else {
+       /* Bogus key, leave untranslated */
        return NULL;
    }