void fetch(void) 
   {
    ............
    ...........

    EXEC SQL FETCH INSERTCUR USING DESCRIPTOR :*psqlda;  
    setcode();

    if(SQLCODE <  0 )
    {
      free_sqlda(psqlda);
      free(psqlda);   
      psqlda =  0 ;
      if(SQLCODE <  0 )
      {
        if(- 501 ==SQLCODE)
        {
          open();
        }
      }
      else
      throw SQLException("Insert:fetch()", SQLCODE, sqlca.sqlerrmc);
    }
    if(SQLCODE ==  100 )
    {
      return;
    }
    // 
    strcpy(szStatement , "INSERT INTO ");
       .........................
       .......................    
    
    strcat(szStatement, "(");
    char *p = szStatement;
    p += strlen(szStatement);


    {   
    for(int i =  0 ; i < psqlda->sqld; ++i)     
    {

       char szColname [  129  ];
       strncpy(szColname,psqlda->sqlvar.sqlname.data,
                psqlda->sqlvar[i].sqlname.length);
       szColname [psqlda->sqlvar[i].sqlname.length] = '\0';  

       char *pszTargetColname = 
             getTgtColname(szColname,
                           szTableName,
                           szTableOwner,
                           getApplyQual(),
                           getSetName()
                           );

      if(pszTargetColname== 0 )
      {
        charForBitData[i] = - 1 ;
        continue;
      }
      strcpy(p,pszTargetColname);
      p += strlen(p);
      strcat(p, ","); 
      p+=strlen(p);

    }
    }   
    if(p [- 1 ] == ',' ) { p[- 1 ] = '\0';  [i]--p; }
 
    strcat(p, ")");
    strcat(p, " VALUES(");
    p += strlen(p);

    for(int i =  0 ; i < psqlda->sqld; ++i)
    {

      unsigned short precision, scale, idx, point, bottom, ind;


      if( ((int)charForBitData) == - 1 ) continue;

      if (
        psqlda->sqlvar[i].sqltype &  1  && *(psqlda->sqlvar[i].sqlind) <  0 )
      {
         [i]/* the data in the sqlda is NULL */ 
        strcat(p, "NULL,"); p+=strlen(p);
      } else
      {
        switch(psqlda->sqlvar.sqltype)
        {
          // character
          case SQL_TYP_INTEGER: 
          case SQL_TYP_NINTEGER:
             sprintf(p, "%ld" , *(long*)psqlda->sqlvar[i].sqldata);
              p += strlen(p);
              *p++ = ',';
              *p   = '\0';

          break;
          case SQL_TYP_SMALL: 
          case SQL_TYP_NSMALL:
              sprintf(p, "%ld" , *(short*)psqlda->sqlvar[i].sqldata);
              p += strlen(p);
              *p++ = ',';
              *p   = '\0';

          break;
          case SQL_TYP_DECIMAL: 
          case SQL_TYP_NDECIMAL:
             
              precision = ((char *)& (psqlda->sqlvar[i].sqllen))[ 0 ]; 
              scale = ((char *)& (psqlda->sqlvar[i].sqllen))[ 1 ];     
                                                      
              if ((precision % 2 ) ==  0 )                
                precision +=  1 ;

              idx = (short)(precision +  2 ) /  2 ; 
              point = precision - scale;        

              bottom = * (psqlda->sqlvar[i].sqldata + idx - 1 ) 
                & 0x000F;    [i]/* sign */ 

              if ((bottom == 0x000D) || (bottom == 0x000B))
              {
                *p++ = '-'; *p= '\0';
              }

              for (ind =  0 ; ind < idx; ++ind)
              {
                short top = * (psqlda->sqlvar.sqldata + ind) 
                        & 0x00F0;
                top = (top >>  4 );
                bottom = * (psqlda->sqlvar[i].sqldata + ind) 
                        & 0x000F;
                if (point [i]-- == 0)
 
                {
                  *p++ = '.'; *p = '\0';
                }
                sprintf(p, "%d", top);
                p+=strlen(p);
                if (ind < idx -  1 )
                {
                  if (point -- == 0)
 
                  {
                   *p++ = '.'; *p = '\0';
                  }
                  sprintf(p, "%d", bottom);
                  p+=strlen(p);
               }
            }
              *p++ = ',';
              *p   = '\0';

          break;
          case SQL_TYP_FLOAT: 
          case SQL_TYP_NFLOAT:
             if(psqlda->sqlvar[i].sqllen== 8 )
             {
               sprintf(p, "%1.8e",  
                 *(double *)psqlda->sqlvar[i].sqldata);
             } else
             {
               sprintf(p, "%1.8e",  
                 *(float *)psqlda->sqlvar[i].sqldata);
             }

             p+=strlen(p);
             *p++ = ',';
             *p   = '\0';

          break;
         case SQL_TYP_CHAR: 
         case SQL_TYP_NCHAR:
            if(charForBitData[i] )
            {
               *p++ = '\'';
               for (int x=0; x<psqlda->sqlvar[i].sqllen ;++x)
               {
                 switch(psqlda->sqlvar[i].sqldata[x])
                 {
                   case '\'': *p++='\'';*p++= psqlda->sqlvar[i].sqldata[x];
                   *p = '\ 0 ';
                   break;
                  default:
                        *p++= ((char *)psqlda->sqlvar[i].sqldata)[x];
                        *p = '\ 0 ';
                   break;
                 }
               }
               // trim tailing spaces
               while(' ' == p[-1] ) --p; 
               *p++ = '\'';
               *p++ = ',';
               *p   = '\0';
              
            } else
            {
              *p++ = 'x';
              *p++ = '\'';
              for(int x=0;x< psqlda->sqlvar[i].sqllen;++x)
              {
                unsigned char ch = ((unsigned char *)
                    (psqlda->sqlvar[i].sqldata))[x];
                *p++ = "0123456789ABCDEF" [ (ch >> 4) & 0x0F ];
                *p++ = "0123456789ABCDEF" [ (ch >> 0) & 0x0F ];
              }
              *p++= '\'';
              *p++ = ',';
              *p   = '\0';
            }
           break;
           case SQL_TYP_DATE:      
           case SQL_TYP_NDATE:
               strcat(p,"DATE("); p+=strlen(p);
               *p++ = '\'';
               {
               for (int x=0; x<psqlda->sqlvar[i].sqllen ;++x)
               {
                 *p++= psqlda->sqlvar[i].sqldata[x];
               }
               }
               // trim tailing spaces
               *p++ = '\'';
               *p++ = ')';
               *p++ = ',';
               *p   = '\0';
           break;
           case SQL_TYP_TIME:      
           case SQL_TYP_NTIME:     
               strcat(p,"TIME("); p+=strlen(p);
               *p++ = '\'';
               {
               for (int x=0; x<psqlda->sqlvar[i].sqllen ;++x)
               {
                 *p++= psqlda->sqlvar[i].sqldata[x];
               }
               }
               // trim tailing spaces
               *p++ = '\'';
               *p++ = ')';
               *p++ = ',';
               *p   = '\0';
              
           break;
           case SQL_TYP_STAMP:
           case SQL_TYP_NSTAMP:
               *p++ = '\'';
               {
               for (int x=0; x<psqlda->sqlvar[i].sqllen ;++x)
               {
                 *p++= psqlda->sqlvar[i].sqldata[x];
               }
               }
               // trim tailing spaces
               *p++ = '\'';
               *p++ = ',';
               *p   = '\0';
           break;
           case SQL_TYP_CSTR:
           case SQL_TYP_NCSTR:
               if(charForBitData[i])
               {
                 *p++ = 'x';
                 *p++ = '\'';
                 int count = 0;
                 for(int x=0;x<psqlda->sqlvar[i].sqllen;++x)
                 {
                   if( 254 <= count )
                   { 
                     count = 0;
                     strcat(p, "' CONCAT x'");
                     p += strlen(p);
                   }

                   unsigned char ch = 
                       ((unsigned char *)(psqlda->sqlvar[i].sqldata))[x];
                   *p++ = "0123456789ABCDEF" [ (ch >> 4) & 0x0F ];
                   *p++ = "0123456789ABCDEF" [ (ch >> 0) & 0x0F ];                   
                 }
                 *p++ = '\'';
               } else
               {
                 *p++ = '\'';
                 *p = '\ 0 ';
                 int count = 0;
                 for(int x=0;x<psqlda->sqlvar[i].sqllen;++x)
                 {
					if( 253 <= count )
					{ 
						count = 0;
						strcat(p, "' CONCAT '");
						p += strlen(p);
					}
                   ++count;
                   switch(  ((char*)psqlda->sqlvar[i].sqldata) [x])
                   {
						case '\ 0 ':  x = psqlda->sqlvar[i].sqllen;
		                  break;
                  case '\'': *p++='\'';
                   *p++= ((char*)psqlda->sqlvar[i].sqldata)[x]; 
                   *p = '\ 0 '; ++count;
                  break;
                  default:
                        *p++= ((char*)psqlda->sqlvar[i].sqldata)[x];
                         *p = '\ 0 ';
                  break;
                   } 
                 } 
                 *p++ = '\'';                 
                 *p =   '\0';
               }
               *p++ = ',';
               *p   = '\0';
           break;
        } 
     }
    }
          ........................
          .........................
    }