/* -*-C++-*-
**********************************************************************
*
* File:         LmRoutineC.cpp
* Description:  Base class for C routines
* Created:      05/14/2008
* Language:     C++
*
// @@@ 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 @@@
**********************************************************************/

#include "LmRoutineC.h"
#include "ComVersionDefs.h"

SQLUDR_CHAR *LmRoutineC::host_data_ = NULL;

LmRoutineC::LmRoutineC(const char   *sqlName,
                       const char   *externalName,
                       const char   *librarySqlName,
                       ComUInt32    numSqlParam,
                       char         *routineSig,
                       ComUInt32    maxResultSets,
                       ComRoutineLanguage language,
                       ComRoutineParamStyle paramStyle,
                       ComRoutineTransactionAttributes transactionAttrs,
                       ComRoutineSQLAccess sqlAccessMode,
                       ComRoutineExternalSecurity externalSecurity,
                       Int32        routineOwnerId,
                       const char   *parentQid,
                       ComUInt32    inputParamRowLen,
                       ComUInt32    outputRowLen,
                       const char   *currentUserName,
                       const char   *sessionUserName,
                       LmParameter  *parameters,
                       LmLanguageManagerC *lm,
                       LmHandle     routine,
                       LmContainer  *container,
                       ComDiagsArea *diagsArea)
  : LmRoutine(container, routine, sqlName, externalName, librarySqlName,
              numSqlParam, maxResultSets,
              language, paramStyle, transactionAttrs, sqlAccessMode,
              externalSecurity, 
	      routineOwnerId,
              parentQid, inputParamRowLen, outputRowLen, 
	          currentUserName, sessionUserName, 
	          parameters, lm),
    callType_(SQLUDR_CALLTYPE_INITIAL),
    stateArea_(NULL),
    udrInfo_(NULL),
    finalCallRequired_(FALSE)
{
  // If we ever support C stored procedures, we need to handle the
  // case of 0 inputs and 0 outputs. For functions there is always at
  // least one output.
  LM_ASSERT(numSqlParam_ > 0);
  
  // Allocate (static) host_data_ if it's not already allocated.
  // This will never be deleted and stays until the process dies.
  if (LmRoutineC::host_data_ == NULL)
  {
    LmRoutineC::host_data_ = (SQLUDR_CHAR *)
      malloc(SQLUDR_STATEAREA_BUFFER_SIZE + 128);
    LM_ASSERT(LmRoutineC::host_data_);
    memset((char *)LmRoutineC::host_data_, 0,
           SQLUDR_STATEAREA_BUFFER_SIZE + 128);
  }

  // Allocate the SQLUDR_STATEAREA structure
  stateArea_ = (SQLUDR_STATEAREA *) malloc(sizeof(SQLUDR_STATEAREA) + 32);
  LM_ASSERT(stateArea_);
  memset(stateArea_, 0, sizeof(SQLUDR_STATEAREA) + 32);
  stateArea_->version = SQLUDR_STATEAREA_CURRENT_VERSION;
  
  stateArea_->host_data.data = LmRoutineC::host_data_;
  stateArea_->host_data.length = SQLUDR_STATEAREA_BUFFER_SIZE;;

  stateArea_->stmt_data.data = (SQLUDR_CHAR *)
    malloc(SQLUDR_STATEAREA_BUFFER_SIZE + 128);
  LM_ASSERT(stateArea_->stmt_data.data);
  memset((char *)stateArea_->stmt_data.data, 0,
         SQLUDR_STATEAREA_BUFFER_SIZE + 128);
  stateArea_->stmt_data.length = SQLUDR_STATEAREA_BUFFER_SIZE;
  
  // Allocate SQLUDR_UDRINFO structure
  udrInfo_ = (SQLUDR_UDRINFO *) malloc(sizeof(SQLUDR_UDRINFO) + 32);
  LM_ASSERT(udrInfo_);
  memset(udrInfo_, 0, sizeof(SQLUDR_UDRINFO) + 32);

  udrInfo_->version = SQLUDR_UDRINFO_CURRENT_VERSION;
  udrInfo_->sql_version = 2400;
  udrInfo_->routine_name = sqlName_;
  // udrInfo_->library_name = librarySqlName_;
  
  const char *qid = getParentQid();
  if (qid)
    udrInfo_->query_id = copy_and_pad(qid, strlen(qid), 8);

  // Allocate memory for SQLUDR_PARAM structure.
  // We assume that the inputs come first, followed by outputs
  ComUInt32 num_inputs = 0, num_outputs = 0;
  SQLUDR_PARAM *sqludr_params = (SQLUDR_PARAM *)
    malloc(numSqlParam_ * sizeof(SQLUDR_PARAM) + 32);
  LM_ASSERT(sqludr_params);
  memset(sqludr_params, 0, numSqlParam_ * sizeof(SQLUDR_PARAM) + 32);

  // Initialize the SQLUDR_PARAM structures
  ComUInt32 dataBytes = 0;
  ComUInt32 i;
  for (i = 0; i < numSqlParam_; i++)
  {
    LmParameter &p = lmParams_[i];

    switch (p.direction())
    {
      case COM_INPUT_COLUMN:
	num_inputs++;
        dataBytes = p.inSize();
        break;
      case COM_OUTPUT_COLUMN:
	num_outputs++;
        dataBytes = p.outSize();
        break;
      default:
        LM_ASSERT1(0, "Invalid parameter mode");
        break;
    }
      
    SQLUDR_PARAM &udfParamInfo = sqludr_params[i];
    udfParamInfo.version = SQLUDR_PARAM_CURRENT_VERSION;
    udfParamInfo.datatype =
      (SQLUDR_INT16) getAnsiTypeFromFSType(p.fsType());
    
    udfParamInfo.data_len = (SQLUDR_UINT32) dataBytes;

    // The parameter name seen by the routine body will be a pointer
    // to the LmParameter's copy of the name.
    udfParamInfo.name = (SQLUDR_CHAR *) p.getParamName();

    // Union u1 contains:
    // * character_set
    // * datetime_code
    // * interval_code
    // * scale
    if (p.isCharacter())
    {
      udfParamInfo.u1.character_set =
        (SQLUDR_INT16) p.encodingCharSet();
    }
    else if (p.isDateTime())
    {
      // For datetime types: ANSI type will be SQLTYPECODE_DATETIME and
      // SQLUDR_PARAM stores a code to indicate date, time, or
      // timestamp.
      udfParamInfo.u1.datetime_code =
        (SQLUDR_INT16) p.getDatetimeCode();
    }
    else if (p.isInterval())
    {
      // For interval types: ANSI type will be SQLTYPECODE_INTERVAL and
      // SQLUDR_PARAM stores a code to indicate start and end fields.
      udfParamInfo.u1.interval_code =
        (SQLUDR_INT16) getIntervalCode(p.fsType());
    }
    else
    {
      udfParamInfo.u1.scale = (SQLUDR_INT16) p.scale();
    }

    // Union u2 contains:
    // * precision
    // * collation
    if (p.isTimeOrTimestamp())
    {
      udfParamInfo.u2.precision = (SQLUDR_INT16) p.getTimePrecision();
    }
    else if (p.isCharacter())
    {
      SQLUDR_COLLATION collation = SQLUDR_COLLATION_UNKNOWN;
      switch (p.collation())
      {
        case CharInfo::DefaultCollation:
          collation = SQLUDR_COLLATION_DEFAULT;
          break;
        case CharInfo::CZECH_COLLATION:
          collation = SQLUDR_COLLATION_CZECH;
          break;
        case CharInfo::CZECH_COLLATION_CI:
          collation = SQLUDR_COLLATION_CZECH_CI;
          break;
        case CharInfo::SJIS_COLLATION:
          collation = SQLUDR_COLLATION_SJIS;
          break;
      }
      udfParamInfo.u2.collation = (SQLUDR_INT16) collation;
    }
    else
    {
      udfParamInfo.u2.precision = (SQLUDR_INT16) p.prec();
    }
    
    // Set data offsets and lengths
    if((getParamStyle() == COM_STYLE_SQLROW) ||
       (getParamStyle() == COM_STYLE_SQLROW_TM))
    {
      switch (p.direction())
      {
        case COM_INPUT_COLUMN:
          udfParamInfo.data_offset = (SQLUDR_UINT32) p.inDataOffset();
          udfParamInfo.ind_offset = (SQLUDR_UINT32) p.inNullIndOffset();
          udfParamInfo.vc_ind_offset = (SQLUDR_UINT32) p.inVCLenIndOffset();
          udfParamInfo.vc_ind_len = (SQLUDR_UINT8) p.inVCLenIndSize();
          break;
        case COM_OUTPUT_COLUMN:
          udfParamInfo.data_offset = (SQLUDR_UINT32) p.outDataOffset();
          udfParamInfo.ind_offset = (SQLUDR_UINT32) p.outNullIndOffset();
          udfParamInfo.vc_ind_offset = (SQLUDR_UINT32) p.outVCLenIndOffset();
          udfParamInfo.vc_ind_len = (SQLUDR_UINT8) p.outVCLenIndSize();
          break;
        default:
          LM_ASSERT1(0, "Invalid parameter mode");
          break;
      }

    } // if (getParamStyle() == COM_STYLE_SQLROW)
    
  } // for each param
    
  // Fill in the rest of udrInfo_ structure fields
  udrInfo_->sql_version = (SQLUDR_UINT16) ComVersion_GetMXV();
  udrInfo_->row_format = SQLUDR_ROWFORMAT_EXPLODED;
  udrInfo_->num_inputs = num_inputs;
  udrInfo_->num_return_values = num_outputs;
  udrInfo_->inputs = (num_inputs > 0 ? &sqludr_params[0] : NULL);
  udrInfo_->return_values =
    (num_outputs > 0 ? &sqludr_params[num_inputs] : NULL);
  udrInfo_->in_row_length = inputParamRowLen_;
  udrInfo_->out_row_length = outputRowLen_;

  switch (getParamStyle())
  {
    case COM_STYLE_SQL:
      udrInfo_->param_style = SQLUDR_PARAMSTYLE_SQL;
      udrInfo_->param_style_version = 1;
      break;
    case COM_STYLE_SQLROW:
    case COM_STYLE_SQLROW_TM:
      udrInfo_->param_style = SQLUDR_PARAMSTYLE_SQLROW;
      udrInfo_->param_style_version = 1;
      break;
    case COM_STYLE_CPP_OBJ:
      // udrInfo_ is not used
      break;
    default:
      LM_ASSERT(0);
      break;
  }

  // Fill current user name and session user name 
  
  if (currentUserName)
    udrInfo_->current_user_name = copy_and_pad(currentUserName, strlen(currentUserName), 8);
  
  if (sessionUserName)
    udrInfo_->session_user_name = copy_and_pad(sessionUserName, strlen(sessionUserName), 8);
  
} // LmRoutineC::LmRoutineC

LmRoutineC::~LmRoutineC()
{
  // udrInfo_->return_values is not needed to be deleted. It's
  // all consecutively allocated memory starting from
  // udrInfo_->inputs.
  SQLUDR_PARAM *sqludr_params = udrInfo_->inputs;
  free(sqludr_params);

  if (stateArea_ && stateArea_->stmt_data.data)
    free(stateArea_->stmt_data.data);

  if (stateArea_)
    free(stateArea_);

  if (udrInfo_)
  {
    if (udrInfo_->query_id)
      free(udrInfo_->query_id);
    if (udrInfo_->current_user_name)
      free(udrInfo_->current_user_name);
    if (udrInfo_->session_user_name)
      free(udrInfo_->session_user_name);
    deletePassThroughInputs();
    free(udrInfo_);
  }
}

void
LmRoutineC::setNumPassThroughInputs(ComUInt32 numPassThroughInputs)
{
  deletePassThroughInputs();

  udrInfo_->num_pass_through = numPassThroughInputs;
  udrInfo_->pass_through = NULL;
  
  if (numPassThroughInputs > 0)
  {
    ComUInt32 numBytes = (numPassThroughInputs * sizeof(SQLUDR_BUFFER)) + 32;
    udrInfo_->pass_through = (SQLUDR_BUFFER *) malloc(numBytes);
    LM_ASSERT(udrInfo_->pass_through);
    memset(udrInfo_->pass_through, 0, numBytes);
  }
}

void
LmRoutineC::setPassThroughInput(ComUInt32 index,
	                        void *data,
	                        ComUInt32 dataLen)
{
  SQLUDR_BUFFER &pass_through_buffer = udrInfo_->pass_through[index];

  pass_through_buffer.length = dataLen;

  if (dataLen > 0)
  {
    LM_ASSERT(data);
    pass_through_buffer.data = copy_and_pad((char *) data, dataLen, 32);
  }
  else
  {
    pass_through_buffer.data = copy_and_pad("", 0, 32);
  }
}

void LmRoutineC::deletePassThroughInputs()
{
  if (udrInfo_)
  {
    if (udrInfo_->num_pass_through > 0)
    {
      LM_ASSERT(udrInfo_->pass_through);

      for (ComUInt32 i = 0; i < udrInfo_->num_pass_through; i++)
      {
        SQLUDR_BUFFER &b = udrInfo_->pass_through[i];
        free(b.data);
      }

      free(udrInfo_->pass_through);
    }
    
    udrInfo_->num_pass_through = 0;
    udrInfo_->pass_through = NULL;
  }
}

LmResult LmRoutineC::handleFinalCall(ComDiagsArea *diagsArea)
{
  setFinalCall();
  return invokeRoutine(NULL, NULL, diagsArea);
}

LmResult
LmRoutineC::processReturnStatus(ComSInt32 retcode, ComDiagsArea *diags)
{
  char *returnMsgText = NULL, *noMsgText = NULL;

  if (retcode == SQLUDR_SUCCESS)
    return LM_OK;

  if (msgText_[0] != '\0')
  {
    returnMsgText = msgText_;
  }
  else
  {
    const char *text =
      "No SQL message text was provided by user-defined function ";
    ComUInt32 msgLen = str_len(text) + str_len(getNameForDiags());
    noMsgText = new (collHeap()) char[msgLen + 1];
    sprintf(noMsgText, "%s%s", text, getNameForDiags());

    returnMsgText = noMsgText;
  }

  // Check the returned SQLSTATE value and raise appropriate
  // SQL code. Valid SQLSTATE values begin with "38" except "38000"
  if ((strncmp(sqlState_, "38", 2) == 0) &&
      (strncmp(sqlState_, "38000", 5) != 0))
  {
    Int32 sqlCode = (retcode == SQLUDR_ERROR) ?
      -LME_CUSTOM_ERROR : LME_CUSTOM_WARNING;

    *diags << DgSqlCode(sqlCode)
           << DgString0(returnMsgText)
	   << DgString1(sqlState_);
    *diags << DgCustomSQLState(sqlState_);
  }
  else
  {
    Int32 sqlCode = (retcode == SQLUDR_ERROR) ? -LME_UDF_ERROR : LME_UDF_WARNING;

    *diags << DgSqlCode(sqlCode)
	   << DgString0(getNameForDiags())
           << DgString1(sqlState_)
           << DgString2(returnMsgText);
  }

  if (noMsgText)
    NADELETEBASIC(noMsgText, collHeap());

  return (retcode == SQLUDR_ERROR) ? LM_ERR: LM_OK;
}