/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
**********************************************************************/

#define _SPUTIL_SP_DLL_
#include "CmpISPStd.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include <iostream>


SP_STATUS SP_FILEINFO_Compile (SP_COMPILE_ACTION /* action */,
			      SP_COMPILE_HANDLE* /* compHandle */,
			      SP_HANDLE /* spHandle */,
			      SP_ERROR_STRUCT* /* error */ )
{
  return SP_SUCCESS;
}

SP_STATUS SP_FILEINFO_InputFormat ( SP_FIELDDESC_STRUCT* format ,
				   Lng32 numFields,
				   SP_COMPILE_HANDLE,
				   SP_HANDLE /* spHandle */,
				   SP_ERROR_STRUCT* error )
{
  if ( numFields != 4 )
    {
      error->error = -19020;
      strcpy(error->optionalString[0], "SP2");
      error->optionalInteger[0] = 4;
      return SP_FAIL;
    }
  strcpy(&(format++->COLUMN_DEF[0]), "filename char(9) character set iso88591");
  strcpy(&(format++->COLUMN_DEF[0]), "counter INT");
  strcpy(&(format++->COLUMN_DEF[0]), "descpt varchar(64) character set iso88591");
  strcpy(&(format++->COLUMN_DEF[0]), "dt1 timestamp");

  return SP_SUCCESS;
}


SP_STATUS SP_FILEINFO_NumOutputs ( Lng32* num,
				  SP_COMPILE_HANDLE,
				  SP_HANDLE /* spHandle */,
				  SP_ERROR_STRUCT* /* error */)
{
  *num = 3;
  return SP_SUCCESS;
}

SP_STATUS SP_FILEINFO_OutputFormat (SP_FIELDDESC_STRUCT* format ,
				   SP_KEYDESC_STRUCT*  keyFields ,
				   Lng32*  numKeyFields ,
				   SP_COMPILE_HANDLE,
				   SP_HANDLE /* spHandle */,
				   SP_ERROR_STRUCT* /* error */  )
{
  strcpy(&((format++)->COLUMN_DEF[0]), "DATA varchar(128) character set iso88591");
  strcpy(&((format++)->COLUMN_DEF[0]), "descpt char(64) character set iso88591");
  strcpy(&((format++)->COLUMN_DEF[0]), "dt timestamp");


  return SP_SUCCESS;
}

SP_STATUS SP_FILEINFO_Process(SP_PROCESS_ACTION action,
			     SP_ROW_DATA  inputData ,
			     SP_EXTRACT_FUNCPTR  eFunc ,
			     SP_ROW_DATA outputData ,
			     SP_FORMAT_FUNCPTR fFunc,
			     SP_KEY_VALUE,
			     SP_KEYVALUE_FUNCPTR,
			     SP_PROCESS_HANDLE*  spProcHandle,
			     SP_HANDLE /* spHandle */,
			     SP_ERROR_STRUCT*  error
			     )
{
  struct SP_FILEINFO_STRUCT
  {
    FILE* fd;
    char desc[256];
    char dt1[64];
  };

  SP_FILEINFO_STRUCT* fileInfo = 0;
  if (action == SP_PROC_OPEN)
  {
    SP_STATUS spStatus = SP_SUCCESS;
    *spProcHandle = 0;
    FILE* fd=0;
    char fileName[256];
    Int32 counter;
    char desc[66];
    char tempStr[64];
    char dt1[64];
    if ( eFunc(0, inputData, 10, tempStr, 0) != SP_NO_ERROR )
      return SP_FAIL;
    else
      // int as input parameter
      if ( eFunc(1, inputData, 4, &counter, 0) != SP_NO_ERROR )
        return SP_FAIL;
      else
        if (eFunc(2, inputData, 66, desc, 0) != SP_NO_ERROR )
          return SP_FAIL;
        else
          if (eFunc(3, inputData, 64, dt1, 0) != SP_NO_ERROR )
            return SP_FAIL;
          else
          {

            // char as input parameter
            tempStr[9] = '\0';
            sprintf(fileName, "%s%d", tempStr, counter);
            if ( !(fd = fopen(fileName,"r") )  )
            {
              error->error = -19021;
              strcpy(error->optionalString[0], "FILEINFO");
              sprintf(error->optionalString[1], "%s does not exist", fileName);
              spStatus = SP_FAIL;
            }
            fileInfo = new SP_FILEINFO_STRUCT;
            fileInfo->fd = fd;

            // varchar as input parameter
            memset(fileInfo->desc, ' ', 255);
            short len;
            memcpy(&len, &desc[0], sizeof(len));
            memcpy(fileInfo->desc, &desc[2], len);
            fileInfo->desc[len] = 0;

            // datetime as input parameter
            memcpy(fileInfo->dt1, dt1, 64);
          }

    *spProcHandle =(SP_PROCESS_HANDLE) fileInfo;
    return spStatus;
  }
  if (action == SP_PROC_FETCH)
  {
    SP_FILEINFO_STRUCT* fileInfo = (SP_FILEINFO_STRUCT*) (*spProcHandle);
    FILE* fd = fileInfo->fd;

    // varchar as output
    char tempstr[128];
    char* p = &tempstr[2];
    if ( fd && fgets(p, 126, fd) )
    {
      char* nlptr = strchr(p, '\n');
      if (nlptr) *nlptr = '\0';
      short len = strlen(p);
      memcpy(&tempstr[0], &len, sizeof(len));
      fFunc(0, outputData, strlen(p) + 2, tempstr, 0);

      // error when fetching output
      if (strncmp(&tempstr[2], "errors", 6) == 0)
      {
        error->error = -19021;
        strcpy(error->optionalString[0], "FILEINFO");
        strcpy(error->optionalString[1], "found an error token");
        (error+1)->error = -19021;
        strcpy((error+1)->optionalString[0], "FILEINFO");
        strcpy((error+1)->optionalString[1], "found an error token");
        (error+2)->error = -19021;
        strcpy((error+2)->optionalString[0], "FILEINFO");
        strcpy((error+2)->optionalString[1], "found an error token");
        return SP_FAIL;
      }
      else if (strncmp(&tempstr[2], "error", 5) == 0)
      {
        error->error = -19021;
        strcpy(error->optionalString[0], "FILEINFO");
        strcpy(error->optionalString[1], "found an error token");
        return SP_FAIL;
      }
      // char as output
      fFunc(1, outputData, strlen(fileInfo->desc), fileInfo->desc, 0);

      // datetime as output
      fFunc(2, outputData, 64, fileInfo->dt1, 0);

      return SP_MOREDATA;
    }
    else
      return SP_SUCCESS;
  }
  if (action == SP_PROC_CLOSE)
  {
    SP_FILEINFO_STRUCT* fileInfo = (SP_FILEINFO_STRUCT*)(*spProcHandle);
    FILE* fd = fileInfo->fd;
    if (fd)
    {
      if ( fclose(fd)  )
      {
        error->error = -19021;
        strcpy(error->optionalString[0], "FILEINFO");
	strcpy(error->optionalString[1], "Can not close file");
	return SP_FAIL;
      }
    }
    else
    {
      error->error = -19021;
      strcpy(error->optionalString[0], "FILEINFO");
      strcpy(error->optionalString[1], "no file opened ");
      return SP_FAIL;
    }
    return SP_SUCCESS;
  }

  return SP_SUCCESS;
}

SP_STATUS SP_CASTING_Compile (SP_COMPILE_ACTION /* action */,
			      SP_COMPILE_HANDLE* /* compHandle */,
			      SP_HANDLE /* spHandle */,
			      SP_ERROR_STRUCT* /* error */ )
{
  return SP_SUCCESS;
}

SP_STATUS SP_CASTING_InputFormat ( SP_FIELDDESC_STRUCT* format ,
				   Lng32 numFields,
				   SP_COMPILE_HANDLE,
				   SP_HANDLE /* spHandle */,
				   SP_ERROR_STRUCT* error )
{
  if ( numFields != 4 )
    {
      error->error = -19020;
      strcpy(error->optionalString[0], "CASTING");
      error->optionalInteger[0] = 4;
      return SP_FAIL;
    }
  strcpy(&((format++)->COLUMN_DEF[0]), "I1 smallint");
  strcpy(&((format++)->COLUMN_DEF[0]), "d1file char(16) character set iso88591 ");
  strcpy(&((format++)->COLUMN_DEF[0]), "description varchar(20) character set iso88591 ");
  strcpy(&((format++)->COLUMN_DEF[0]), "dt timestamp" );

  return SP_SUCCESS;
}


SP_STATUS SP_CASTING_NumOutputs ( Lng32* num,
				  SP_COMPILE_HANDLE,
				  SP_HANDLE /* spHandle */,
				  SP_ERROR_STRUCT* /* error */)
{
  *num = 4;
  return SP_SUCCESS;
}

SP_STATUS SP_CASTING_OutputFormat (SP_FIELDDESC_STRUCT* format ,
				   SP_KEYDESC_STRUCT*  keyFields ,
				   Lng32*  numKeyFields ,
				   SP_COMPILE_HANDLE,
				   SP_HANDLE /* spHandle */,
				   SP_ERROR_STRUCT* /* error */  )
{
  strcpy(&((format++)->COLUMN_DEF[0]), "DATA int");
  strcpy(&((format++)->COLUMN_DEF[0]), "datetime1 timestamp");
  strcpy(&((format++)->COLUMN_DEF[0]), "description varchar(256) character set iso88591");
  strcpy(&((format++)->COLUMN_DEF[0]), "tag char(64) character set iso88591");

  return SP_SUCCESS;
}

inline void varchar2String(char* varchar, short size, char*& string, short& len)
{
  // This inline will convert the sql varchar format string into a
  // C/C++ style string ( null terminated if enough length )
  memcpy(&len, varchar, sizeof(short));
  string = &varchar[sizeof(short)];
  if ((UInt32)len + sizeof(short) < (UInt32)size )
    string[len] = 0;
}

inline short string2Varchar(char* string, char* varchar, short size)
{
  if ((UInt32)strlen(string) + sizeof(short) > (UInt32)size )
    return 0;
  short len = strlen(string);
  memcpy(varchar, &len, sizeof(short));
  memcpy(varchar+sizeof(short), string, len);
  return 1;
}

SP_STATUS SP_CASTING_Process(SP_PROCESS_ACTION action,
			     SP_ROW_DATA  inputData ,
			     SP_EXTRACT_FUNCPTR  eFunc ,
			     SP_ROW_DATA outputData ,
			     SP_FORMAT_FUNCPTR fFunc,
			     SP_KEY_VALUE,
			     SP_KEYVALUE_FUNCPTR,
			     SP_PROCESS_HANDLE*  spProcHandle,
			     SP_HANDLE /* spHandle */,
			     SP_ERROR_STRUCT*  error
			     )
{
  struct CounterStruct
  {
    FILE* fd;
    Int32 max;
    Int32 current;
    char desc[256];
    char tag[40];
  };

  if (action == SP_PROC_OPEN)
  {
    SP_STATUS spStatus = SP_SUCCESS;
    char counter[16];
    memset(counter, ' ', 15);
    counter[15] = 0;
    short len;
    if ( eFunc(0, inputData, 16, counter, 1) == SP_NO_ERROR )
    {
      char* cp;
      varchar2String(counter, 16, cp, len);
      Int32 iCounter = atoi(cp);
      CounterStruct* counterStruct = new CounterStruct();
      counterStruct->max = iCounter;
      counterStruct->current = 0;
      char fileName[64];
      if (eFunc(1, inputData, 64, fileName, 1) == SP_NO_ERROR)
      {
        char* fp;
        varchar2String(fileName, 64, fp, len);
        if ( !(counterStruct->fd = fopen(fp,"r") )  )
        {
          error->error = -19021;
          strcpy(error->optionalString[0], "CASTING");
          sprintf(error->optionalString[1], "%s does not exist", fileName);
          delete counterStruct;
          return SP_FAIL;
        }
        char tempStr[256];
        if ( eFunc(2, inputData, 256, tempStr, 1) != SP_NO_ERROR)
        {
          delete counterStruct;
          return SP_FAIL;
		}
        char* tp;
        varchar2String(tempStr, 256, tp, len);
        strcpy(counterStruct->desc, tp);
        if ( eFunc(3, inputData, 40, tempStr, 1) != SP_NO_ERROR)
        {
          error->error = -19021;
          strcpy(error->optionalString[0], "CASTING");
          strcpy(error->optionalString[1], "can't get the 4th parameter");
		  delete counterStruct;
          return SP_FAIL;
        }
        varchar2String(tempStr, 40, tp, len);
        strcpy(counterStruct->tag, tp);
        *spProcHandle =(SP_PROCESS_HANDLE) counterStruct;
      }
      else
	  {
	    delete counterStruct;
              return SP_FAIL;

	  }
	 delete counterStruct;
      return spStatus;
    }
    else
      return SP_FAIL;
  }
  if (action == SP_PROC_FETCH)
  {
    char string[256] = "";
    CounterStruct* counter = (CounterStruct *)(*spProcHandle);
    if ( counter )
    {
      if ( counter->current >= counter->max ||
        (counter->fd && !fgets(string, 256, counter->fd) ) )
        return SP_SUCCESS;
      else
      {
        char* lnPtr = strchr(string, '\n');
        if (lnPtr) *lnPtr='\0';
        char tempStr[1024];
        char id[64];
        sprintf(id, "%d", counter->current++);
        string2Varchar(id, tempStr, 1024);
        fFunc(0, outputData, 1024, tempStr, 1);
        string2Varchar(string, tempStr, 1024);
        fFunc(1, outputData, 1024, tempStr, 1);
        string2Varchar(counter->desc, tempStr, 1024);
        fFunc(2, outputData, 1024, tempStr, 1);
        string2Varchar(counter->tag, tempStr, 1024);
        fFunc(3, outputData, 1024, tempStr, 1);
        return SP_MOREDATA;
      }
    }
    else
    {
      error->error = -19021;
      strcpy(error->optionalString[0], "CASTING");
      strcpy(error->optionalString[1], "Not a valid CounterStruct*");
      return SP_FAIL;
    }
  }
  if (action == SP_PROC_CLOSE)
  {
    CounterStruct* counter = (CounterStruct *) (*spProcHandle);
    if ( counter->fd )
      fclose(counter->fd);
    delete counter;
    return SP_SUCCESS;
  }

  return SP_SUCCESS;
}

SP_STATUS SP_NOINPUT_Compile (SP_COMPILE_ACTION /* action */,
			      SP_COMPILE_HANDLE* /* compHandle */,
			      SP_HANDLE /* spHandle */,
			      SP_ERROR_STRUCT* /* error */ )
{
  return SP_SUCCESS;
}

SP_STATUS SP_NOINPUT_InputFormat ( SP_FIELDDESC_STRUCT* format ,
				   Lng32 numFields,
				   SP_COMPILE_HANDLE,
				   SP_HANDLE /* spHandle */,
				   SP_ERROR_STRUCT* error )
{
  if ( numFields != 0 )
    {
      error->error = -19020;
      strcpy(error->optionalString[0], "CASTING");
      error->optionalInteger[0] = 0;
      return SP_FAIL;
    }

  return SP_SUCCESS;
}


SP_STATUS SP_NOINPUT_NumOutputs ( Lng32* num,
				  SP_COMPILE_HANDLE,
				  SP_HANDLE /* spHandle */,
				  SP_ERROR_STRUCT* /* error */)
{
  *num = 0;
  return SP_SUCCESS;
}

SP_STATUS SP_NOINPUT_OutputFormat (SP_FIELDDESC_STRUCT* format ,
				   SP_KEYDESC_STRUCT*  /*keyFields */ ,
				   Lng32*  /*numKeyFields */ ,
				   SP_COMPILE_HANDLE,
				   SP_HANDLE /* spHandle */,
				   SP_ERROR_STRUCT* /* error */  )
{
  return SP_SUCCESS;
}

SP_STATUS SP_NOINPUT_Process(SP_PROCESS_ACTION action,
			     SP_ROW_DATA  inputData ,
			     SP_EXTRACT_FUNCPTR  eFunc ,
			     SP_ROW_DATA outputData ,
			     SP_FORMAT_FUNCPTR fFunc,
			     SP_KEY_VALUE,
			     SP_KEYVALUE_FUNCPTR,
			     SP_PROCESS_HANDLE*  spProcHandle,
			     SP_HANDLE /* spHandle */,
			     SP_ERROR_STRUCT*  error
			     )
{
  struct InfoStruct
  {
    char varchar[256];
  };

  if (action == SP_PROC_OPEN)
  {
    SP_STATUS spStatus = SP_SUCCESS;
    InfoStruct* is = new InfoStruct;
    char data[6];
    strcpy (data, "1000");
    string2Varchar(data, is->varchar, 256);
    *spProcHandle =(SP_PROCESS_HANDLE) is;
    cout << "In SP_NOINPUT_PROCESS, open" << endl << flush;
    return spStatus;
  }
  if (action == SP_PROC_FETCH)
  {
    return SP_SUCCESS;
  }
  if (action == SP_PROC_CLOSE)
  {
    cout << "In SP_NOINPUT_PROCESS, close" << endl << flush;
    return SP_SUCCESS;
  }

  return SP_SUCCESS;
}

SP_STATUS SP_PARSING_Compile (SP_COMPILE_ACTION action,
			      SP_COMPILE_HANDLE*  cmpHandle ,
			      SP_HANDLE /* spHandle */,
			      SP_ERROR_STRUCT* /* error */ )
{
  if ( action == SP_COMP_INIT )
  {
    *cmpHandle = (SP_COMPILE_HANDLE) new Int32(0);
    cout << "in SP_PARSING_Compile SP_COMP_INIT" << endl;
  }
  if ( action == SP_COMP_EXIT )
  {
    delete ((Int32*)(*cmpHandle));
    cout << "in SP_PARSING_COMPILE SP_COMP_EXIT" << endl;
  }
  return SP_SUCCESS;
}

SP_STATUS SP_PARSING_InputFormat ( SP_FIELDDESC_STRUCT* format ,
				   Lng32 numFields,
				   SP_COMPILE_HANDLE,
				   SP_HANDLE /* spHandle */,
				   SP_ERROR_STRUCT* error )
{
  if ( numFields != 2 )
    {
      error->error = -19020;
      strcpy(error->optionalString[0], "PARSING");
      error->optionalInteger[0] = 2;
      return SP_FAIL;
    }

  strcpy(&((format++)->COLUMN_DEF[0]), "string varchar(40) character set iso88591");
  strcpy(&((format++)->COLUMN_DEF[0]), "i1 int");
  return SP_SUCCESS;
}

SP_STATUS SP_PARSING_PARSER (
     char* param, /* input, null terminated */
     SP_COMPILE_HANDLE cmpHandle, /* input */
     SP_HANDLE spHandle, /* input */
     SP_ERROR_STRUCT* error /* output */
     )
{
  if (strcmp(param, "1")==0)
    *((Int32*)cmpHandle) = 1;
  else if (strcmp(param, "2") == 0 )
    *((Int32*)cmpHandle) = 2;
  else
  {
    error->error = -19021;
    strcpy(error->optionalString[0], "SP_PARSING_PARSER ");
    sprintf(error->optionalString[1], " invalid parameter : %s ", param);
    error->error = -19021;
    return SP_FAIL;
  }
  return SP_SUCCESS;
}


SP_STATUS SP_PARSING_NumOutputs ( Lng32* num,
				  SP_COMPILE_HANDLE cmpHandle,
				  SP_HANDLE /* spHandle */,
				  SP_ERROR_STRUCT* /* error */)
{
  Int32 param = *( (Int32*)cmpHandle );
  if ( param == 1 || param == 2)
    *num = param;
  else
    return SP_FAIL;
  return SP_SUCCESS;
}

SP_STATUS SP_PARSING_OutputFormat (SP_FIELDDESC_STRUCT* format ,
				   SP_KEYDESC_STRUCT*  /*keyFields */ ,
				   Lng32*  /*numKeyFields */ ,
				   SP_COMPILE_HANDLE cmpHandle,
				   SP_HANDLE /* spHandle */,
				   SP_ERROR_STRUCT* /* error */  )
{

  Int32 param = *( ( Int32*)cmpHandle );
  if ( param == 1 )
  {
    strcpy ( &((format++)->COLUMN_DEF[0]), "i1 int" );
    return SP_SUCCESS;
  }
  if ( param == 2 )
  {
    strcpy ( &((format++)->COLUMN_DEF[0]), "i1 int");
    strcpy ( &((format++)->COLUMN_DEF[0]), "c2 char(5) character set iso88591");
    return SP_SUCCESS;
  }

  return SP_FAIL;
}

SP_STATUS SP_PARSING_Process(SP_PROCESS_ACTION action,
			     SP_ROW_DATA  inputData ,
			     SP_EXTRACT_FUNCPTR  eFunc ,
			     SP_ROW_DATA outputData ,
			     SP_FORMAT_FUNCPTR fFunc,
			     SP_KEY_VALUE,
			     SP_KEYVALUE_FUNCPTR,
			     SP_PROCESS_HANDLE*  spProcHandle,
			     SP_HANDLE /* spHandle */,
			     SP_ERROR_STRUCT*  error
			     )
{
  struct InfoStruct
  {
    Int32 param; // 1 or 2
    Int32 max;
    Int32 counter;
    char string[5];
  };

  if (action == SP_PROC_OPEN)
  {
    SP_STATUS spStatus = SP_SUCCESS;
    char p[64];
    if (eFunc(0, inputData, 42, p, 0) == SP_NO_ERROR)
    {
      char* ptr;
      short len;
      varchar2String(p, 64, ptr, len);
      Int32 param = atoi(ptr);
      if ( param != 1 && param != 2 )
        return SP_FAIL;
      InfoStruct* is = new InfoStruct;
      is->param = param;
      is->counter = 0;
      eFunc(1, inputData, sizeof(Int32), &(is->max), 0);
      memcpy(is->string, "12345", 5);
      *spProcHandle = is;
      return spStatus;
    }
  }
  if (action == SP_PROC_FETCH)
  {
    InfoStruct* is = (InfoStruct *)(*spProcHandle);
    if ( is )
    {
      if ( is->counter > is->max )
        return SP_SUCCESS;
      fFunc(0, outputData, sizeof(Int32), &(is->counter), 0);
      is->counter++;

      if ( is->param == 2 )
      {
        fFunc(1, outputData, 5, &is->string[0], 0);
      }
      return SP_MOREDATA;
    }
    return SP_FAIL;
  }
  if (action == SP_PROC_CLOSE)
  {
    return SP_SUCCESS;
  }

  return SP_SUCCESS;
}

SP_STATUS SP_DELAY_Compile (SP_COMPILE_ACTION action,
			    SP_COMPILE_HANDLE*  cmpHandle ,
			    SP_HANDLE /* spHandle */,
			    SP_ERROR_STRUCT* /* error */ )
{
  return SP_SUCCESS;
}

SP_STATUS SP_DELAY_InputFormat ( SP_FIELDDESC_STRUCT* format ,
				   Lng32 numFields,
				   SP_COMPILE_HANDLE,
				   SP_HANDLE /* spHandle */,
				   SP_ERROR_STRUCT* error )
{
  if ( numFields != 2 )
    {
      error->error = -19020;
      strcpy(error->optionalString[0], "DELAY");
      error->optionalInteger[0] = 2;
      return SP_FAIL;
    }

  strcpy(&((format++)->COLUMN_DEF[0]), "i1 int");
  strcpy(&((format++)->COLUMN_DEF[0]), "i2 int");
  return SP_SUCCESS;
}

SP_STATUS SP_DELAY_NumOutputs ( Lng32* num,
				SP_COMPILE_HANDLE cmpHandle,
				SP_HANDLE /* spHandle */,
				SP_ERROR_STRUCT* /* error */)
{
  *num = 1;
  return SP_SUCCESS;
}

SP_STATUS SP_DELAY_OutputFormat (SP_FIELDDESC_STRUCT* format ,
				 SP_KEYDESC_STRUCT*  /*keyFields */ ,
				 Lng32*  /*numKeyFields */ ,
				 SP_COMPILE_HANDLE cmpHandle,
				 SP_HANDLE /* spHandle */,
				 SP_ERROR_STRUCT* /* error */  )
{
  strcpy(&((format++)->COLUMN_DEF[0]), "c1 int");

  return SP_SUCCESS;
}

SP_STATUS SP_DELAY_Process(SP_PROCESS_ACTION action,
			   SP_ROW_DATA  inputData ,
			   SP_EXTRACT_FUNCPTR  eFunc ,
			   SP_ROW_DATA outputData ,
			   SP_FORMAT_FUNCPTR fFunc,
			   SP_KEY_VALUE,
			   SP_KEYVALUE_FUNCPTR,
			   SP_PROCESS_HANDLE*  spProcHandle,
			   SP_HANDLE /* spHandle */,
			   SP_ERROR_STRUCT*  error
			   )
{
  struct InfoStruct
  {
    Int32 delay;
    Int32 max;
    Int32 counter;
  };

  if (action == SP_PROC_OPEN)
  {
    SP_STATUS spStatus = SP_SUCCESS;
    Int32 tempi;
    if (eFunc(0, inputData, sizeof(Int32), &tempi, 0) == SP_NO_ERROR)
    {
      Int32 tempi2;
      if (eFunc(1, inputData, sizeof(Int32), &tempi2, 0) == SP_NO_ERROR )
      {
        InfoStruct* is = new InfoStruct;
        is->delay = tempi;
        is->max = tempi2;
        is->counter = 0;
        *spProcHandle = is;
        return spStatus;
      }
    }
    return SP_FAIL;
  }
  if (action == SP_PROC_FETCH)
  {
    InfoStruct* is = (InfoStruct *)(*spProcHandle);
    if ( is )
    {
      if ( is->counter > is->max )
        return SP_SUCCESS;
      //Sleep(is->delay);
      for ( Int32 i=0; i < is->delay; i++ ) i = (i * 10) / 10;
      fFunc(0, outputData, sizeof(Int32), &(is->counter), 0);
      is->counter++;

      return SP_MOREDATA;
    }
    return SP_FAIL;
  }
  if (action == SP_PROC_CLOSE)
  {
    delete (InfoStruct *)(*spProcHandle);
    return SP_SUCCESS;
  }

  return SP_SUCCESS;
}

// ERROR is a stored procedure to test the CMPASSERT feature,
// It is to test that once exception happens in compilation, the
// SP_ERROR_Compile routine will be called for SP_COMP_EXIT.
// If exception happens in execution time, the
// SP_ERROR_Process routine will be called to close the ISP.
// To test this feature, you need
// 1. the following ISP implementation.
// 2. testing code in arkcmp/CmpStoredProc.cpp, search for SP_ERROR_
// 3. testing code in arkcmp/CmpISPUtils.cpp, seach for SP_ERROR_
//    The above 2 places are commented out for now, need to uncomment
//    them to test this feature.
// 4. from sqlci, run
//    select * from table(tdmsip('ERROR', 'TestCMPASSERT'));
//    should trigger the CMPASSERT in compilation time.
// 5. from sqlci, run
//    select * from table(tdmisp('ERROR', 'TestCMPASSERTEXE'));
//    should trigger the CMPASSERT in execution time.
SP_STATUS SP_ERROR_Compile (SP_COMPILE_ACTION action,
			    SP_COMPILE_HANDLE*  cmpHandle ,
			    SP_HANDLE /* spHandle */,
			    SP_ERROR_STRUCT* error )
{
  static Int32 parserCalled = 0;
  if ( action == SP_COMP_EXIT )
  {
    if ( parserCalled )
      return SP_SUCCESS;
    error->error = -19021;
    strcpy(error->optionalString[0], "SP_ERROR_Compile ");
    sprintf(error->optionalString[1], " SP_COMP_EXIT called ");
    return SP_FAIL;
  }
  else
  {
    parserCalled = 0;
    *cmpHandle = &parserCalled;
    return SP_SUCCESS;
  }
}

SP_STATUS SP_ERROR_InputFormat ( SP_FIELDDESC_STRUCT* format ,
				 Lng32 numFields,
				 SP_COMPILE_HANDLE,
				 SP_HANDLE /* spHandle */,
				 SP_ERROR_STRUCT* error )
{
  if ( numFields != 1 )
    {
      error->error = -19020;
      strcpy(error->optionalString[0], "ERROR");
      error->optionalInteger[0] = 1;
      return SP_FAIL;
    }

  strcpy(&((format++)->COLUMN_DEF[0]), "i1 char(16) character set iso88591");
  return SP_SUCCESS;
}

SP_STATUS SP_ERROR_PARSER (
     char* param, /* input, null terminated */
     SP_COMPILE_HANDLE cmpHandle, /* input */
     SP_HANDLE spHandle, /* input */
     SP_ERROR_STRUCT* error /* output */
     )
{
  Int32* parserFlag;
  parserFlag = ((Int32*)cmpHandle);
  *parserFlag = 1;
  return SP_SUCCESS;
}

SP_STATUS SP_ERROR_NumOutputs ( Lng32* num,
				SP_COMPILE_HANDLE cmpHandle,
				SP_HANDLE /* spHandle */,
				SP_ERROR_STRUCT* /* error */)
{
  *num = 1;
  return SP_SUCCESS;
}

SP_STATUS SP_ERROR_OutputFormat (SP_FIELDDESC_STRUCT* format ,
				 SP_KEYDESC_STRUCT*  /*keyFields */ ,
				 Lng32*  /*numKeyFields */ ,
				 SP_COMPILE_HANDLE cmpHandle,
				 SP_HANDLE /* spHandle */,
				 SP_ERROR_STRUCT* /* error */  )
{
  strcpy(&((format++)->COLUMN_DEF[0]), "i1 char(16) character set iso88591");
  return SP_SUCCESS;
}

SP_STATUS SP_ERROR_Process(SP_PROCESS_ACTION action,
			   SP_ROW_DATA  inputData ,
			   SP_EXTRACT_FUNCPTR  eFunc ,
			   SP_ROW_DATA outputData ,
			   SP_FORMAT_FUNCPTR fFunc,
			   SP_KEY_VALUE,
			   SP_KEYVALUE_FUNCPTR,
			   SP_PROCESS_HANDLE*  spProcHandle,
			   SP_HANDLE /* spHandle */,
			   SP_ERROR_STRUCT*  error
			   )
{

  if (action == SP_PROC_OPEN)
  {
    static Int32 withData = 0;
    *spProcHandle = &withData;
    return SP_SUCCESS;
  }
  if (action == SP_PROC_FETCH)
  {
    char temp[16];
    if (eFunc(0, inputData, 16, temp, 0) == SP_NO_ERROR)
    {
      *( (Int32*)(*spProcHandle) ) = 1;
      fFunc(0, outputData, 16, temp, 0);
      return SP_SUCCESS;
    }
    return SP_FAIL;
  }
  if (action == SP_PROC_CLOSE)
  {
    if ( * ((Int32*)(*spProcHandle)) != 1 )
    {
      error->error = -19021;
      strcpy(error->optionalString[0], "SP_ERROR_PROCESS ");
      sprintf(error->optionalString[1], " SP_PROC_CLOSE called ");
      return SP_FAIL;
    }
    //delete (InfoStruct *)(*spProcHandle);
    return SP_SUCCESS;
  }

  return SP_SUCCESS;
}

// COL16 is a internal stored procedure that will return with 16 columns
// of data. This is used to do performance testing. QA is using a test case
// with 13 cols of int and 3 cols of char(52) to test performance.
// input : counter int;  -- number of rows returned.
//         filename varchar(64) -- input file name.
// output : col1 - col13 int; -- sequence number starting from 1
//          col14 - col16 char(52); -- if filename exists, read from filename,
//                                  -- otherwise, some constant value.
SP_STATUS SP_COL16_Compile (SP_COMPILE_ACTION action,
			    SP_COMPILE_HANDLE*  cmpHandle ,
			    SP_HANDLE /* spHandle */,
			    SP_ERROR_STRUCT* /* error */ )
{
  return SP_SUCCESS;
}

SP_STATUS SP_COL16_InputFormat ( SP_FIELDDESC_STRUCT* format ,
				 Lng32 numFields,
				 SP_COMPILE_HANDLE,
				 SP_HANDLE /* spHandle */,
				 SP_ERROR_STRUCT* error )
{
  if ( numFields != 2 )
    {
      error->error = -19020;
      strcpy(error->optionalString[0], "COL16");
      error->optionalInteger[0] = 2;
      return SP_FAIL;
    }

  strcpy(&((format++)->COLUMN_DEF[0]), "maxCounter int");
  strcpy(&((format++)->COLUMN_DEF[0]), "fname varchar(64) character set iso88591");
  return SP_SUCCESS;
}

SP_STATUS SP_COL16_NumOutputs ( Lng32* num,
				SP_COMPILE_HANDLE cmpHandle,
				SP_HANDLE /* spHandle */,
				SP_ERROR_STRUCT* /* error */)
{
  *num = 16;
  return SP_SUCCESS;
}

SP_STATUS SP_COL16_OutputFormat (SP_FIELDDESC_STRUCT* format ,
				 SP_KEYDESC_STRUCT*  /*keyFields */ ,
				 Lng32*  /*numKeyFields */ ,
				 SP_COMPILE_HANDLE cmpHandle,
				 SP_HANDLE /* spHandle */,
				 SP_ERROR_STRUCT* /* error */  )
{
  strcpy(&((format++)->COLUMN_DEF[0]), "c1 int");
  strcpy(&((format++)->COLUMN_DEF[0]), "c2 int");
  strcpy(&((format++)->COLUMN_DEF[0]), "c3 int");
  strcpy(&((format++)->COLUMN_DEF[0]), "c4 int");
  strcpy(&((format++)->COLUMN_DEF[0]), "c5 int");
  strcpy(&((format++)->COLUMN_DEF[0]), "c6 int");
  strcpy(&((format++)->COLUMN_DEF[0]), "c7 int");
  strcpy(&((format++)->COLUMN_DEF[0]), "c8 int");
  strcpy(&((format++)->COLUMN_DEF[0]), "c9 int");
  strcpy(&((format++)->COLUMN_DEF[0]), "c10 int");
  strcpy(&((format++)->COLUMN_DEF[0]), "c11 int");
  strcpy(&((format++)->COLUMN_DEF[0]), "c12 int");
  strcpy(&((format++)->COLUMN_DEF[0]), "c13 int");
  strcpy(&((format++)->COLUMN_DEF[0]), "c14 char(52) character set iso88591");
  strcpy(&((format++)->COLUMN_DEF[0]), "c15 char(52) character set iso88591");
  strcpy(&((format++)->COLUMN_DEF[0]), "c16 char(52) character set iso88591");

  return SP_SUCCESS;
}

SP_STATUS SP_COL16_Process(SP_PROCESS_ACTION action,
			   SP_ROW_DATA  inputData ,
			   SP_EXTRACT_FUNCPTR  eFunc ,
			   SP_ROW_DATA outputData ,
			   SP_FORMAT_FUNCPTR fFunc,
			   SP_KEY_VALUE,
			   SP_KEYVALUE_FUNCPTR,
			   SP_PROCESS_HANDLE*  spProcHandle,
			   SP_HANDLE /* spHandle */,
			   SP_ERROR_STRUCT*  error
			   )
{
  struct InfoStruct
  {
    Int32 max;
    Int32 counter;
    FILE* fd;
  };

  if (action == SP_PROC_OPEN)
  {
    SP_STATUS spStatus = SP_SUCCESS;
    Int32 tempi;
    if (eFunc(0, inputData, sizeof(Int32), &tempi, 0) == SP_NO_ERROR)
    {
      char p[65];
      if (eFunc(1, inputData, 64, p, 0) == SP_NO_ERROR)
      {
        char* ptr;
        short len;
        varchar2String(p, 64, ptr, len);
        InfoStruct* is = new InfoStruct;
        is->max = tempi;
        is->counter = 0;
        is->fd = fopen ( ptr, "r");
        *spProcHandle = is;
        return spStatus;
      }
    }
    return SP_FAIL;
  }
  if (action == SP_PROC_FETCH)
  {
    InfoStruct* is = (InfoStruct *)(*spProcHandle);
    if ( is )
    {
      if ( is->counter > is->max )
        return SP_SUCCESS;
      for ( Int32 i=0; i < 13; i++ )
        fFunc(i, outputData, sizeof(Int32), &(is->counter), 0);
      char temp[64];
      const char tempConst[] =
        "Constant String                                            ";
      char* pch = &temp[0];
      if ( is->fd )
      {
        memset (temp, ' ', 63);
        fgets(temp, 64, is->fd);
        char* lnPtr = strchr(temp, '\n');
        if (lnPtr) *lnPtr = '\0';
      }
      else
        pch = (char*)(&tempConst[0]);
      fFunc(13, outputData, 52, pch, 0);
      fFunc(14, outputData, 52, pch, 0);
      fFunc(15, outputData, 52, pch, 0);

      is->counter++;

      return SP_MOREDATA;
    }
    return SP_FAIL;
  }
  if (action == SP_PROC_CLOSE)
  {
    delete (InfoStruct *)(*spProcHandle);
    return SP_SUCCESS;
  }

  return SP_SUCCESS;
}

SP_STATUS SP_ROW998_Compile (SP_COMPILE_ACTION action,
			     SP_COMPILE_HANDLE*  cmpHandle ,
			     SP_HANDLE /* spHandle */,
			     SP_ERROR_STRUCT* /* error */ )
{
  return SP_SUCCESS;
}

SP_STATUS SP_ROW998_InputFormat ( SP_FIELDDESC_STRUCT* format ,
				  Lng32 numFields,
				  SP_COMPILE_HANDLE,
				  SP_HANDLE /* spHandle */,
				  SP_ERROR_STRUCT* error )
{
  if ( numFields != 1 )
    {
      error->error = -19020;
      strcpy(error->optionalString[0], "ROW998");
      error->optionalInteger[0] = 1;
      return SP_FAIL;
    }

  strcpy(&((format++)->COLUMN_DEF[0]), "maxCounter int");
  return SP_SUCCESS;
}

SP_STATUS SP_ROW998_NumOutputs ( Lng32* num,
				 SP_COMPILE_HANDLE cmpHandle,
				 SP_HANDLE /* spHandle */,
				 SP_ERROR_STRUCT* /* error */)
{
  *num = 1;
  return SP_SUCCESS;
}

SP_STATUS SP_ROW998_OutputFormat (SP_FIELDDESC_STRUCT* format ,
				  SP_KEYDESC_STRUCT*  /*keyFields */ ,
				  Lng32*  /*numKeyFields */ ,
				  SP_COMPILE_HANDLE cmpHandle,
				  SP_HANDLE /* spHandle */,
				  SP_ERROR_STRUCT* /* error */  )
{
  strcpy(&((format++)->COLUMN_DEF[0]), "c1 char(998) character set iso88591");

  return SP_SUCCESS;
}

SP_STATUS SP_ROW998_Process(SP_PROCESS_ACTION action,
			    SP_ROW_DATA  inputData ,
			    SP_EXTRACT_FUNCPTR  eFunc ,
			    SP_ROW_DATA outputData ,
			    SP_FORMAT_FUNCPTR fFunc,
			    SP_KEY_VALUE,
			    SP_KEYVALUE_FUNCPTR,
			    SP_PROCESS_HANDLE*  spProcHandle,
			    SP_HANDLE /* spHandle */,
			    SP_ERROR_STRUCT*  error
			   )
{
  struct InfoStruct
  {
    Int32 max;
    Int32 counter;
  };

  if (action == SP_PROC_OPEN)
  {
    SP_STATUS spStatus = SP_SUCCESS;
    Int32 tempi;
    if (eFunc(0, inputData, sizeof(Int32), &tempi, 0) == SP_NO_ERROR)
    {
      InfoStruct* is = new InfoStruct;
      is->max = tempi;
      is->counter = 0;
      *spProcHandle = is;
      return spStatus;
    }
    return SP_FAIL;
  }
  if (action == SP_PROC_FETCH)
  {
    InfoStruct* is = (InfoStruct *)(*spProcHandle);
    if ( is )
    {
      if ( is->counter > is->max )
        return SP_SUCCESS;
      char temp[998];
      const char tempConst[] =
        "Constant String                                            ";
      sprintf(temp, "%s %d", tempConst, is->counter);
      fFunc(0, outputData, 998, temp, 0);

      is->counter++;

      return SP_MOREDATA;
    }
    return SP_FAIL;
  }
  if (action == SP_PROC_CLOSE)
  {
    delete (InfoStruct *)(*spProcHandle);
    return SP_SUCCESS;
  }

  return SP_SUCCESS;
}

Int32 SQLISP_INIT(SP_REGISTER_FUNCPTR rFunc, SP_DLL_HANDLE* h)
{
  if (!rFunc)
  {
    return 0;
  }

  char funcName[SP_STRING_MAX_LENGTH];
  strcpy(funcName, "FILEINFO");
  rFunc(funcName,
	  SP_FILEINFO_Compile,
	  SP_FILEINFO_InputFormat,
	  0,
	  SP_FILEINFO_NumOutputs,
	  SP_FILEINFO_OutputFormat,
	  SP_FILEINFO_Process,
	  0,
	  CMPISPVERSION);
  strcpy(funcName, "CASTING");
  rFunc(funcName,
	  SP_CASTING_Compile,
	  SP_CASTING_InputFormat,
	  0,
	  SP_CASTING_NumOutputs,
	  SP_CASTING_OutputFormat,
	  SP_CASTING_Process,
	  0,
	  CMPISPVERSION);
  strcpy(funcName, "NOINPUT");
  rFunc(funcName,
    SP_NOINPUT_Compile,
    SP_NOINPUT_InputFormat,
    0,
    SP_NOINPUT_NumOutputs,
    SP_NOINPUT_OutputFormat,
    SP_NOINPUT_Process,
    0,
    CMPISPVERSION);
  strcpy(funcName, "PARSING");
  rFunc(funcName,
    SP_PARSING_Compile,
    SP_PARSING_InputFormat,
    SP_PARSING_PARSER,
    SP_PARSING_NumOutputs,
    SP_PARSING_OutputFormat,
    SP_PARSING_Process,
    0,
    CMPISPVERSION);
  strcpy(funcName, "DELAY");
  rFunc(funcName,
    SP_DELAY_Compile,
    SP_DELAY_InputFormat,
    0,
    SP_DELAY_NumOutputs,
    SP_DELAY_OutputFormat,
    SP_DELAY_Process,
    0,
    CMPISPVERSION);
  strcpy(funcName, "ERROR");
  rFunc(funcName,
    SP_ERROR_Compile,
    SP_ERROR_InputFormat,
    SP_ERROR_PARSER,
    SP_ERROR_NumOutputs,
    SP_ERROR_OutputFormat,
    SP_ERROR_Process,
    0,
    CMPISPVERSION);
  strcpy(funcName, "COL16");
  rFunc(funcName,
    SP_COL16_Compile,
    SP_COL16_InputFormat,
    0,
    SP_COL16_NumOutputs,
    SP_COL16_OutputFormat,
    SP_COL16_Process,
    0,
    CMPISPVERSION);
  strcpy(funcName, "ROW998");
  rFunc(funcName,
    SP_ROW998_Compile,
    SP_ROW998_InputFormat,
    0,
    SP_ROW998_NumOutputs,
    SP_ROW998_OutputFormat,
    SP_ROW998_Process,
    0,
    CMPISPVERSION);

  return 1;
}

Int32 SQLISP_EXIT(SP_DLL_HANDLE)
{
  //cout << "in SQLISP_EXIT" << endl;
  return 1;
}