示例#1
0
文件: aodbc.c 项目: AmziLS/interfaces
TF EXPFUNC p_db_connect(ENGid eid)
{
   HDBC hdbc;
   char szDataSource[80];
   char szUserID[40];
   char szPassword[40];

   if (pVAR != lsGetParmType(eid, 1))
   {
      lsErrRaise(eid, "db_connect instantiation error: arg 1 must be var");
      return FALSE;
   }
   g_lsRC = lsGetParm(eid, 2, cSTR, szDataSource);
   if (g_lsRC != OK) goto LS_ERROR;
   g_lsRC = lsGetParm(eid, 3, cSTR, szUserID);
   if (g_lsRC != OK) goto LS_ERROR;
   g_lsRC = lsGetParm(eid, 4, cSTR, szPassword);
   if (g_lsRC != OK) goto LS_ERROR;

   g_RC = SQLAllocConnect(g_hEnv, &hdbc);
   /* set up error handler */
   g_hDBC = hdbc;
   g_hSTMT = SQL_NULL_HSTMT;
   g_eid = eid;
   ERROR_CHK("SQLAllocConnect");

   // Added this line to get around erroneous messages:
   // S1010:[Microsoft][ODBC SQL Server Driver]Function sequence error 
   // Fix from MS Knowledge Article 179226
   // SQL_PRESERVE_CURSORS - note new name in actual call
   // This only applies to SQL Server, so hopefully, nothing bad will
   // happen if it fails.

   g_RC = SQLSetConnectOption(hdbc, SQL_COPT_SS_PRESERVE_CURSORS, NULL);

   g_RC = SQLConnect(hdbc,
         (UCHAR*)szDataSource, SQL_NTS,
         (UCHAR*)szUserID, SQL_NTS,
         (UCHAR*)szPassword, SQL_NTS);
   ERROR_CHK("SQLConnect");

   lsUnifyParm(eid, 1, cADDR, &hdbc);
   return TRUE;
LS_ERROR:
   return(lserror());
ODBC_ERROR:
   return FALSE;
}
// module/1 version
AMZIFUNC  cv_module_1 ( ENGid   Engine )
   {
	register int	i ;
	char		module_name [ 256 ] ;


	// Check if help file is loaded
	if ( ! check_help_loaded ( Engine ) )
		return ( FALSE ) ;

	// Get module name
	lsGetParm ( Engine, 1, cSTR, module_name ) ;

	for ( i = 0 ; i < Help -> GetModuleCount ( ) ; i ++ )
	   {
		Module *	module = Help -> GetModule ( i ) ;

		
		// Module has been found : print it
		if  ( ! stricmp ( module_name, module -> Name ) )
			print_module_entries ( Engine, i, module ) ;

		delete  module ;
	     }

	return ( TRUE ) ;
    }
示例#3
0
文件: aodbc.c 项目: AmziLS/interfaces
TF EXPFUNC p_db_disconnect(ENGid eid)
{
   HDBC hdbc;

   g_lsRC = lsGetParm(eid, 1, cADDR, &hdbc);
   if (g_lsRC != OK) goto LS_ERROR;
   
   /* set up error handler */
   g_hDBC = hdbc;
   g_hSTMT = SQL_NULL_HSTMT;
   g_eid = eid;

   g_RC = SQLDisconnect(hdbc);
   ERROR_CHK("SQLDisconnect");

   g_RC = SQLFreeConnect(hdbc);
   ERROR_CHK("SQLFreeConnect");

   errchk("lsODBC");
   return TRUE;   
LS_ERROR:
   return(lserror());
ODBC_ERROR:
   return FALSE;
}
示例#4
0
/*
 * Class:     amzi_ls_ARulesLogicServer
 * Method:    GetStrParm
 * Signature: (I)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_amzi_ls_ARulesLogicServer_GetStrParm
  (JNIEnv * jenv, jobject jobj, jint iarg)
{
   RC   rc;
   aCHAR* str;

   GET_EID(e);
   int len = lsStrParmLen(e, (int)iarg);

   if (len < 0)                         // jmg 
       len = 0;                         // jmg

   str = new aCHAR[len+1];
   rc = lsGetParm(e, (int)iarg, cWSTR, str);

   if (rc != OK)                        // jmg
       *str = 0;                        // jmg

   jCHAR *jcstr = new jCHAR[len+1];
   ac_to_jc(jcstr, str, len);
   jstring jstr = jenv->NewString(jcstr, len);
   delete[] str;
   delete[] jcstr;
   if (rc != OK)
      amzi_error(jenv, e, "GetStrParm");

   return jstr;
}
示例#5
0
文件: aodbc.c 项目: AmziLS/interfaces
TF EXPFUNC p_db_freeq(ENGid eid)
{
   QUERY* pq;

   g_lsRC = lsGetParm(eid, 1, cADDR, &pq);
   if (g_lsRC != OK) goto LS_ERROR;
   query_del(pq);
   return TRUE;
LS_ERROR:
   return(lserror());
}
示例#6
0
/*
 * Class:     amzi_ls_ARulesLogicServer
 * Method:    GetFloatParm
 * Signature: (I)D
 */
JNIEXPORT jdouble JNICALL Java_amzi_ls_ARulesLogicServer_GetFloatParm
  (JNIEnv * jenv, jobject jobj, jint iarg)
{
   RC     rc;
   double d;

   GET_EID(e);
   rc = lsGetParm(e, (int)iarg, cDOUBLE, &d);
   if (rc != OK)
      amzi_error(jenv, e, "GetFloatParm");

   return (jdouble)d;
}
示例#7
0
/*
 * Class:     amzi_ls_ARulesLogicServer
 * Method:    GetIntParm
 * Signature: (I)I
 */
JNIEXPORT jint JNICALL Java_amzi_ls_ARulesLogicServer_GetIntParm
  (JNIEnv * jenv, jobject jobj, jint iarg)
{
   RC     rc;
   int    i;

   GET_EID(e);
   rc = lsGetParm(e, (int)iarg, cINT, &i);
   if (rc != OK)
      amzi_error(jenv, e, "GetIntParm");

   return (jint)i;
}
示例#8
0
/*
 * Class:     amzi_ls_ARulesLogicServer
 * Method:    GetParm
 * Signature: (I)J
 */
JNIEXPORT jlong JNICALL Java_amzi_ls_ARulesLogicServer_GetParm
  (JNIEnv * jenv, jobject jobj, jint iarg)
{
   TERM t;
   RC   rc;

   GET_EID(e);
   rc = lsGetParm(e, (int)iarg, cTERM, &t);
   if (rc != OK)
      amzi_error(jenv, e, "GetParm");

   return (jlong)(ajptr)t;
}
AMZIFUNC cv_string_file ( ENGid	Engine )
   {
	char *			String ;
	characters		FileName [ 1024 ] ;
	int			Length ;
	register FILE *		fp ;
	


	// Retrieve the filename
	lsGetParm ( Engine, 2, cSTR, FileName ) ;

	// Open the file (in binary mode, otherwise file length will be greater
	// than bytes read, since CRLF are converted)
	if ( ( fp = fopen( FileName, "rb" ) )  ==  NULL )
		return( FALSE ) ;

	Length = FileLength( fp ) ;
	String = ( char * ) malloc( Length + 1 ) ;

	// Check if we are running out of memory
	if ( String  ==  NULL )
	   {
		fclose ( fp ) ;
		return ( FALSE ) ;
	     }

	// Read the file then unify the result
	fread( String, 1, Length, fp ) ;
	fclose( fp ) ;

	String [ Length ] = '\0' ;

	lsUnifyParm ( Engine, 1, cSTR, String ) ;
	free( String ) ;

	return( TRUE ) ;
     }
AMZIFUNC  cv_usage_1 ( ENGid   Engine )
   {
	register int	i, j, k ;
	char		predicate_name	     [ 256 ] ;
	char		predicate_name_arity [ 256 ] ;
	TERM		FA ;
	register int	found = 0 ;


	// Check if help file is loaded
	if ( ! check_help_loaded ( Engine ) )
		return ( FALSE ) ;

	// We can specify :
	//	help(term).
	//	help('term/arity')
	//	help(term/arity)
	// In the latter case, we receive a term instead of an atom, so we must
	// convert it to a string
	if  ( lsGetParm ( Engine, 1, cSTR, predicate_name )  !=  OK )
	   {
		lsGetParm ( Engine, 1, cTERM, & FA ) ;
		lsTermToStr ( Engine, FA, predicate_name_arity, sizeof ( predicate_name_arity ) ) ;
	     }
	else	
		* predicate_name_arity = 0 ;

	// Cycle through the modules
	for ( i = 0 ; i < Help -> GetModuleCount ( ) ; i ++ )
	   {
		Module *	module = Help -> GetModule ( i ) ;

		// Cycle through the predicates
		for  ( j = 0 ; j < Help -> GetPredicateCount ( i ) ; j ++ )
		    {
			char			buffer [ 256 ] ;
			Predicate *		pred = Help -> GetPredicate ( i, j ) ;



			// Make sure that it will succeed even if an arity is 
			// provided
			sprintf ( buffer, "%s/%d",
				pred -> Name, pred -> Arity ) ;

			if  ( ! strnicmp ( predicate_name, pred -> Name, strlen ( predicate_name ) )  ||
			      ! strnicmp ( predicate_name, buffer, strlen ( predicate_name ) )        || 
			      ! strnicmp ( predicate_name_arity, buffer, strlen ( predicate_name ) )  ||
			        strstr   ( pred -> Name, predicate_name )  !=  NULL )
			   {
				char		usage [ 256 ] ;

				// May need a linefeed between this predicate and the preceding one
				if  ( found )
					prolog_printf  ( Engine, "\n" ) ;
				found = 1 ;

				// Build the usage string
				sprintf ( usage, "Usage : %s( ", pred -> Name ) ;

				for ( k = 0 ; pred -> Arguments [k]. Name  !=  NULL ; k ++ )
				   {
					strcat ( usage, pred -> Arguments [k]. Name ) ;

					if  ( pred -> Arguments [k+1]. Name  !=  NULL ) 
						strcat ( usage, ", " ) ;
				     }

				strcat ( usage, " )." ) ;
 
				// print the usage string and short description
				prolog_printf ( Engine, "%s\n\t%s\n",
					usage, pred -> ShortDescription ) ;
			    }

			delete  pred ;
		     }

		delete  module ;
	     }

	return ( TRUE ) ;
    }
AMZIFUNC  cv_help_1 ( ENGid   Engine )
   {
	register int	i, j ;
	Argument *	ap ;
	char		predicate_name	     [ 256 ] ;
	char		predicate_name_arity [ 256 ] ;
	TERM		FA ;


	// Check if help file is loaded
	if ( ! check_help_loaded ( Engine ) )
		return ( FALSE ) ;

	// We can specify :
	//	help(term).
	//	help('term/arity')
	//	help(term/arity)
	// In the latter case, we receive a term instead of an atom, so we must
	// convert it to a string
	if  ( lsGetParm ( Engine, 1, cSTR, predicate_name )  !=  OK )
	   {
		lsGetParm ( Engine, 1, cTERM, & FA ) ;
		lsTermToStr ( Engine, FA, predicate_name_arity, sizeof ( predicate_name_arity ) ) ;
	     }
	else	
		* predicate_name_arity = 0 ;

	// Cycle through all modules
	for ( i = 0 ; i < Help -> GetModuleCount ( ) ; i ++ )
	   {
		Module *	module = Help -> GetModule ( i ) ;

		// Cycle through each module predicates
		for  ( j = 0 ; j < Help -> GetPredicateCount ( i ) ; j ++ )
		    {
			char			buffer [ 256 ] ;
			Predicate *		pred = Help -> GetPredicate ( i, j ) ;


			// Make sure that it will succeed even if an arity is 
			// provided
			sprintf ( buffer, "%s/%d",
				pred -> Name, pred -> Arity ) ;

			// Found ?
			if  ( ! stricmp ( predicate_name, pred -> Name )  ||
			      ! stricmp ( predicate_name, buffer )        || 
			      ! stricmp ( predicate_name_arity, buffer ) )
			   {
				// Yes : print the name
				prolog_printf ( Engine, "Name          : %s/%d\n",
					pred -> Name, pred -> Arity ) ;

				// Print the module name
				prolog_printf ( Engine, "Module        : %s (%s)\n", 
					module -> Name, module -> Description ) ;

				// Print the usage string
				prolog_printf ( Engine, "Usage         : %s\n",
					pred -> ShortDescription ) ;

				// Print Succeeds when and Fails when
				if  ( pred -> SucceedsWhen  !=  NULL ) 
					prolog_printf ( Engine, "Succeeds when : %s\n",
						pred -> SucceedsWhen ) ;

				if  ( pred -> FailsWhen  !=  NULL ) 
					prolog_printf ( Engine, "Fails when    : %s\n",
						pred -> FailsWhen ) ;

				// Print long description
				if  ( pred -> LongDescription  !=  NULL )
					prolog_printf ( Engine, "Description   :\n\t%s\n",
						pred -> LongDescription ) ;

				// Argument header
				if  ( pred -> Arguments [0]. Name  !=  NULL )	
					prolog_printf ( Engine, "Arguments     :\n" ) ;

				// Print argument list
				for  ( ap = pred -> Arguments ; ap -> Name !=  NULL ; ap ++ )
				   {
					prolog_printf ( Engine, "\tArgument %d : %s (access = %s)\n",
						ap -> Position, ap -> Name, ap -> Access ) ;
					prolog_printf ( Engine, "\t\t%s\n",
						ap -> Description ) ;
				     }

				prolog_printf ( Engine, "\n" ) ;
			    }
			delete  pred ;
		     }

		delete  module ;
	     }

	return ( TRUE ) ;
    }
AMZIFUNC  cv_where_1 ( ENGid   Engine )
   {
	register int	i, j ;
	char		predicate_name	     [ 256 ] ;
	char		predicate_name_arity [ 256 ] ;
	TERM		FA ;
	register int	found		=  0 ;


	// Check if help file is loaded
	if ( ! check_help_loaded ( Engine ) )
		return ( FALSE ) ;

	// We can specify :
	//	help(term).
	//	help('term/arity')
	//	help(term/arity)
	// In the latter case, we receive a term instead of an atom, so we must
	// convert it to a string
	if  ( lsGetParm ( Engine, 1, cSTR, predicate_name )  !=  OK )
	   {
		lsGetParm ( Engine, 1, cTERM, & FA ) ;
		lsTermToStr ( Engine, FA, predicate_name_arity, sizeof ( predicate_name_arity ) ) ;
	     }
	else	
		* predicate_name_arity = 0 ;

	// Cycle through the modules
	for ( i = 0 ; i < Help -> GetModuleCount ( ) ; i ++ )
	   {
		Module *	module = Help -> GetModule ( i ) ;

		// Cycle through the predicates
		for  ( j = 0 ; j < Help -> GetPredicateCount ( i ) ; j ++ )
		    {
			char			buffer [ 256 ] ;
			Predicate *		pred = Help -> GetPredicate ( i, j ) ;



			// Make sure that it will succeed even if an arity is 
			// provided
			sprintf ( buffer, "%s/%d",
				pred -> Name, pred -> Arity ) ;

			if  ( ! strnicmp ( predicate_name, pred -> Name, strlen ( predicate_name ) )  ||
			      ! strnicmp ( predicate_name, buffer, strlen ( predicate_name ) )        || 
			      ! strnicmp ( predicate_name_arity, buffer, strlen ( predicate_name ) )  ||
			        strstr   ( pred -> Name, predicate_name )  !=  NULL )
			   {
				char		buffer [ 256 ] ;

				// Print the header before the first found predicate
				if  ( ! found ) 
					prolog_printf ( Engine, "predicate '%s' can be found in the following module(s) : \n",
						predicate_name ) ;

				found = 1 ;

				// Format functor/arity to a certain width
				sprintf ( buffer, "%s/%d", pred -> Name, pred -> Arity ) ;

				//
				prolog_printf ( Engine, "\t%-20s  %-20s  %s\n",
					buffer,
					module -> Name, module -> Description ) ;
			    }

			delete  pred ;
		     }

		delete  module ;
	     }

	return ( TRUE ) ;
    }
示例#13
0
文件: aodbc.c 项目: AmziLS/interfaces
TF EXPFUNC p_db_fetch(ENGid eid)
{
   QUERY* pq;
   HSTMT  hstmt;
   TERM   tcols;
   TERM   t;
   COL*   pCol;

#ifdef _DEBUG
TERM xt1, xt2;
char xbuf1[512], xbuf2[512];
#endif

   if (pVAR != lsGetParmType(eid, 2))
   {
      lsErrRaise(eid, "db_fetch instantiation error: arg 2 must be var");
      return FALSE;
   }

   g_lsRC = lsGetParm(eid, 1, cADDR, &pq);
   if (g_lsRC != OK) goto LS_ERROR;
   hstmt = pq->hstmt;
   
   /* set up error handler */
   g_hSTMT = hstmt;
   g_eid = eid;


   if ( SQL_NO_DATA_FOUND == (g_RC = SQLFetch(hstmt)) )
   {
      DUMPLOG("no data found");
      query_del(pq);
      return FALSE;
   }
   ERROR_CHK("SQLFetch");
   DUMPLOG("found data");

   g_lsRC = lsMakeList(eid, &tcols);
   if (g_lsRC != OK) goto LS_ERROR;

   for (pCol = pq->clist; pCol != NULL; pCol = pCol->next)
   {
      switch(pCol->pdtype)
      {
      case pdATOM:
         g_lsRC = lsMakeAtom(eid, &t, pCol->s);
         if (g_lsRC != OK) goto LS_ERROR;
         break;
      case pdSTR:
         g_lsRC = lsMakeStr(eid, &t, pCol->s);
         if (g_lsRC != OK) goto LS_ERROR;
         break;
      case pdINT:
         g_lsRC = lsMakeInt(eid, &t, pCol->i);
         if (g_lsRC != OK) goto LS_ERROR;
         break;
      case pdFLOAT:
         g_lsRC = lsMakeFloat(eid, &t, pCol->f);
         if (g_lsRC != OK) goto LS_ERROR;
         break;
      case pdDOUBLE:
         g_lsRC = lsMakeFloat(eid, &t, pCol->g);
         if (g_lsRC != OK) goto LS_ERROR;
         break;
      case pdDATE:
         g_lsRC = lsMakeFA(eid, &t, "date", 3);
         if (g_lsRC != OK) goto LS_ERROR;
         lsUnifyArg(eid, &t, 1, cSHORT, &(pCol->d->year));
         lsUnifyArg(eid, &t, 2, cSHORT, &(pCol->d->month));
         lsUnifyArg(eid, &t, 3, cSHORT, &(pCol->d->day));
         break;
      case pdTIME:
         g_lsRC = lsMakeFA(eid, &t, "time", 3);
         if (g_lsRC != OK) goto LS_ERROR;
         lsUnifyArg(eid, &t, 1, cSHORT, &(pCol->t->hour));
         lsUnifyArg(eid, &t, 2, cSHORT, &(pCol->t->minute));
         lsUnifyArg(eid, &t, 3, cSHORT, &(pCol->t->second));
         break;
      default:
         messout("Unsupported Prolog type for ODBC fetch");
      }
      g_lsRC = lsPushList(eid, &tcols, t);
      if (g_lsRC != OK) return(lserror());
   }

/* #ifdef _DEBUG
lsGetParm(eid, 2, cTERM, &xt1);
lsTermToStrQ(eid, xt1, xbuf1, 500);
lsTermToStrQ(eid, xt2, xbuf2, 500);
#endif */

   lsUnifyParm(eid, 2, cTERM, &tcols);

   return TRUE;
LS_ERROR:
   return(lserror());
ODBC_ERROR:
   return FALSE;
}
示例#14
0
文件: aodbc.c 项目: AmziLS/interfaces
TF EXPFUNC p_db_query(ENGid eid)
/* db_query/5
   ex.
   db_query(HConnect, PQuery,
      $select mother, father from person where name = ?$,
      ['Someones Name'],
      [string, string]). */
{
   HSTMT   hstmt;
   HDBC    hdbc;
   char*   sQ = NULL;
   int     iParm = 1;
   int     iCol = 1;
   TERM    tParms, tCols;
   char*   sBuf = NULL;
   char    sType[80];
   TERM    t;
   pTYPE   ptyp;
   QUERY*  pq;
   char*   s;
   long    len;
   long*   pl;
   float*  pf;
   double* pd;
   long    i;
   //float   f;
   double  g;
   DATE_STRUCT* pdate;
   TIME_STRUCT* ptime;
   char   sMsg[512];
#ifdef _DEBUG
char xbuf1[512], xbuf2[512];
#endif

   if (pVAR != lsGetParmType(eid, 2))
   {
      lsErrRaise(eid, "db_query instantiation error: arg 2 must be var");
      return FALSE;
   }

   /* create stmt structure */

   pq = query_new();

   /* add stmt handle to structure */

   g_lsRC = lsGetParm(eid, 1, cADDR, &hdbc);
   if (g_lsRC != OK) goto LS_ERROR;

/* #ifdef _DEBUG
xtest(hdbc);
#endif */

   g_RC = SQLAllocStmt(hdbc, &hstmt);
   /* set up error handler */
   g_hDBC = hdbc;
   g_hSTMT = hstmt;
   g_eid = eid;
   ERROR_CHK("SQLAllocStmt");

   pq->hstmt = hstmt;

   /* get query string from Prolog */

   sQ = (char*)malloc(lsStrParmLen(eid, 3)+1);
   g_lsRC = lsGetParm(eid, 3, cSTR, sQ);
   if (g_lsRC != OK) goto LS_ERROR;

   /* prepare SQL query */

   //g_RC = SQLPrepare(hstmt, (UCHAR*)sQ, SQL_NTS);
   //errchk("lsODBC");

   /* get parameter list from Prolog */

   g_lsRC = lsGetParm(eid, 4, cTERM, &tParms);
   if (g_lsRC != OK) goto LS_ERROR;

#ifdef _DEBUG
lsTermToStrQ(eid, tParms, xbuf1, 500);
#endif

   /* walk input list */

   while (OK == lsPopList(eid, &tParms, cTERM, &t))
   {
      /* bind parameter for each */
      ptyp = lsGetTermType(eid, t);
      switch(ptyp)
      {
      case pATOM:
      case pSTR:
         sBuf = (char*)malloc(lsStrTermLen(eid, t) + 1);
         g_lsRC = lsGetTerm(eid, t, cSTR, sBuf);
         if (g_lsRC != OK) goto LS_ERROR;
         len = strlen(sBuf) + 1;
         s = query_addstrparm(pq, sBuf);
         g_ParmSize = SQL_NTS;
         g_RC = SQLBindParameter(hstmt, (UWORD)iParm, SQL_PARAM_INPUT, SQL_C_CHAR,
               SQL_CHAR, (UDWORD)len, 0, s, (SDWORD)len, &g_ParmSize);
         ERROR_CHK("SQLBindParameter");
         break;
      case pINT:
         g_lsRC = lsGetTerm(eid, t, cLONG, &i);
         if (g_lsRC != OK) goto LS_ERROR;
         pl = query_addintparm(pq, i);
         g_ParmSize = 0;
         g_RC = SQLBindParameter(hstmt, (UWORD)iParm, SQL_PARAM_INPUT, SQL_C_SLONG,
               SQL_INTEGER, 4, 0, pl, 4, &g_ParmSize);
         ERROR_CHK("SQLBindParameter");
         break;
      case pFLOAT:
         g_lsRC = lsGetTerm(eid, t, cDOUBLE, &g);
         if (g_lsRC != OK) goto LS_ERROR;
         pd = query_adddoubleparm(pq, g);
         g_ParmSize = 0;
         g_RC = SQLBindParameter(hstmt, (UWORD)iParm, SQL_PARAM_INPUT, SQL_C_DOUBLE,
               SQL_DOUBLE, 8, 0, pd, 8, &g_ParmSize);
         ERROR_CHK("SQLBindParameter");
         break;
      default:
         messout("Unsupported Prolog type for ODBC input");
      }
      iParm++;
   }

   /* get column list from Prolog */

   g_lsRC = lsGetParm(eid, 5, cTERM, &tCols);
   if (g_lsRC != OK) goto LS_ERROR;
#ifdef _DEBUG
lsTermToStrQ(eid, tCols, xbuf2, 500);
#endif
   /* walk output list */

   while (OK == lsPopList(eid, &tCols, cSTR, sType))
   {
      /* bind col for each */
      switch(sType[0])
      {
      case 'a':
         len = 1 + atol(&sType[1]);
         s = query_addstrcol(pq, pdATOM, len);
         g_ColSize = SQL_NO_TOTAL;
         g_RC = SQLBindCol(hstmt, (UWORD)iCol, SQL_C_CHAR, s,
               len, &g_ColSize);
         ERROR_CHK("SQLBindCol");
         break;        
      case 's':
         len = 1 + atol(&sType[1]);
         s = query_addstrcol(pq, pdSTR, len);
         g_ColSize = SQL_NO_TOTAL;
         g_RC = SQLBindCol(hstmt, (UWORD)iCol, SQL_C_CHAR, s,
               len, &g_ColSize);
         ERROR_CHK("SQLBindCol");
         break;        
      case 'i':
         pl = query_addintcol(pq);
         g_ColSize = 0;
         g_RC = SQLBindCol(hstmt, (UWORD)iCol, SQL_C_SLONG, pl,
               4, &g_ColSize);
         ERROR_CHK("SQLBindCol");
         break;
      case 'f':
         pf = query_addfloatcol(pq);
         g_ColSize = 0;
         g_RC = SQLBindCol(hstmt, (UWORD)iCol, SQL_C_FLOAT, pf,
               4, &g_ColSize);
         ERROR_CHK("SQLBindCol");
         break;
      case 'g':
         pd = query_adddoublecol(pq);
         g_ColSize = 0;
         g_RC = SQLBindCol(hstmt, (UWORD)iCol, SQL_C_DOUBLE, pd,
               8, &g_ColSize);
         ERROR_CHK("SQLBindCol");
         break;
      case 'd':
         pdate = query_adddatecol(pq);
         g_ColSize  = 0;  // ignored for date
         g_RC = SQLBindCol(hstmt, (UWORD)iCol, SQL_C_DATE, pdate,
               6, &g_ColSize);
         ERROR_CHK("SQLBindCol");
         break;
      case 't':
         ptime = query_addtimecol(pq);
         g_RC = SQLBindCol(hstmt, (UWORD)iCol, SQL_C_TIME, ptime,
               6, &g_ColSize);
         ERROR_CHK("SQLBindCol");
         break;
      default:
         sprintf(sMsg,
            "Unsupported Prolog type '%c' for ODBC output", sType[0]);
         messout(sMsg);
      }
      iCol++;
   }

   /* execute query and return pointer to query */

   //g_RC = SQLExecute(hstmt);
   //errchk("lsODBC");

   g_RC = SQLExecDirect(hstmt, (UCHAR*)sQ, SQL_NTS);
   ERROR_CHK("SQLExecDirect");

   lsUnifyParm(eid, 2, cADDR, &pq);
   if (sQ != NULL) free(sQ);
   if (sBuf != NULL) free(sBuf);
   return TRUE;
LS_ERROR:
   if (sQ != NULL) free(sQ);
   if (sBuf != NULL) free(sBuf);
   return(lserror());
ODBC_ERROR:
   if (sQ != NULL) free(sQ);
   if (sBuf != NULL) free(sBuf);
   return FALSE;
}