/****************************************************************************
* File:         LmRoutineCppObj.cpp
* Description:  LM routine for C++ routines using the object interface
* Created:      01/22/2015
* 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 "LmRoutineCppObj.h"
#include "LmParameter.h"
#include "LmLangManagerC.h"
#include "ComUser.h"

// Utility method to set up a "wall" before and after a buffer.
// This wall is set to a specific pattern. If someone accidentally
// writes beyond the buffer boundaries, the wall will get clobbered
// and a subsequent validation will raise an error.


#define WALL_STRING "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
#define WALL_STRING_LEN 8

//////////////////////////////////////////////////////////////////////
//
// Class LmRoutineCppObj
// If we get errors in creating this object, fill diagsArea and return
// error. Caller is responsbile to cleanup by calling destructor.
//
//////////////////////////////////////////////////////////////////////
LmRoutineCppObj::LmRoutineCppObj(
  tmudr::UDRInvocationInfo *invocationInfo,
  tmudr::UDRPlanInfo    *planInfo,
  tmudr::UDR            *interfaceObj,
  const char            *sqlName,
  const char            *externalName,
  const char            *librarySqlName,
  ComUInt32              maxResultSets,
  ComRoutineTransactionAttributes transactionAttrs,
  ComRoutineSQLAccess    sqlAccessMode,
  ComRoutineExternalSecurity externalSecurity,
  Int32                  routineOwnerId,
  LmLanguageManagerC    *lm,
  LmContainer           *container,
  ComDiagsArea          *diags)
  : LmRoutine(container,
              (LmHandle) interfaceObj,
              sqlName,
              externalName,
              librarySqlName,
              0,
              maxResultSets,
              COM_LANGUAGE_CPP,
              COM_STYLE_CPP_OBJ,
              transactionAttrs,
              sqlAccessMode,
              externalSecurity, 
              routineOwnerId,
              invocationInfo->getQueryId().c_str(),
              invocationInfo->par().getRecordLength(),
              invocationInfo->out().getRecordLength(),
              invocationInfo->getCurrentUser().c_str(),
              invocationInfo->getSessionUser().c_str(),
              NULL,
              lm),
    planInfos_(collHeap()),
    invocationInfo_(invocationInfo),
    interfaceObj_(interfaceObj),
    paramRow_(NULL),
    inputRows_(NULL),
    outputRow_(NULL)
{
  if (planInfo)
    planInfos_.insertAt(0, planInfo);
  interfaceObj_->getNextRowPtr_ = NULL; // set these with setFunctionPtrs()
  interfaceObj_->emitRowPtr_    = NULL;
  numInputTables_   = invocationInfo->getNumTableInputs();

  if (inputParamRowLen_ > 0)
    {
      paramRow_ = new(collHeap()) char[inputParamRowLen_];
      memset(paramRow_,0,inputParamRowLen_);
      const_cast<tmudr::ParameterListInfo &>(invocationInfo->par()).setRowPtr(paramRow_);
    }

  // inputRows_ and outputRow_ will be allocated in setRuntimeInfo() 
}

LmRoutineCppObj::~LmRoutineCppObj()
{
  // assert that caller has called dealloc before destroying this object
  LM_ASSERT(invocationInfo_ == NULL &&
            interfaceObj_ == NULL &&
            outputRow_ == NULL);
}

LmResult LmRoutineCppObj::dealloc(ComDiagsArea *diagsArea)
{
  LmResult result = LM_OK;

  delete invocationInfo_;
  invocationInfo_ = NULL;

  for (CollIndex i=0; i<planInfos_.getUsedLength(); i++)
    if (planInfos_.used(i))
      delete planInfos_[i];
  planInfos_.clear();

  if (paramRow_)
    {
      NADELETEBASIC(paramRow_, collHeap());
      paramRow_ = NULL;
    }

  if (inputRows_)
    {
      for (int i=0; i<numInputTables_; i++)
        if (inputRows_[i])
          NADELETEBASIC((inputRows_[i]), collHeap());
      NADELETEBASIC(inputRows_, collHeap());
      inputRows_ = NULL;
    }
  if (outputRow_)
    {
      // actually allocated buffer started where the wall starts
      NADELETEBASIC((outputRow_ - WALL_STRING_LEN), collHeap());
      outputRow_ = NULL;
    }

  try
    {
      // delete the interface object, the virtual destructor may call user code
      delete interfaceObj_;
    }
  catch (tmudr::UDRException e)
    {
      *diagsArea << DgSqlCode(-LME_UDR_METHOD_ERROR)
                 << DgString0("destructor")
                 << DgString1(getNameForDiags())
                 << DgString2(e.getMessage().c_str());
      result = LM_ERR;
    }
  catch (...)
    {
      *diagsArea << DgSqlCode(-LME_UDR_METHOD_ERROR)
                 << DgString0("destructor")
                 << DgString1(getNameForDiags())
                 << DgString2("General exception.");
      result = LM_ERR;
    }

  interfaceObj_ = NULL;

  return result;
}

const char *LmRoutineCppObj::getParentQid()
{
  return invocationInfo_->getQueryId().c_str();
}

LmResult LmRoutineCppObj::setRuntimeInfo(
     const char   *parentQid,
     int           totalNumInstances,
     int           myInstanceNum,
     ComDiagsArea *da)
{
  invocationInfo_->setQueryId(parentQid);
  invocationInfo_->setTotalNumInstances(totalNumInstances);
  invocationInfo_->setMyInstanceNum(myInstanceNum);

  // allocate row buffers
  if (numInputTables_ > 0)
    {
      inputRows_ = new (collHeap()) char *[numInputTables_];
      for (int i=0; i<numInputTables_; i++)
        {
          int inputRowLength = invocationInfo_->in(i).recordLength_;

          if (inputRowLength > 0)
            {
              inputRows_[i] = new(collHeap()) char[inputRowLength];
              memset(inputRows_[i], 0, inputRowLength);
              const_cast<tmudr::TableInfo &>(
                   invocationInfo_->in(i)).setRowPtr(inputRows_[i]);
            }
          else
            // at compile time, input rows are not specified
            inputRows_[i] = NULL;
        }
    }
  else
    {
      inputRows_ = NULL;
    }

  if (outputRowLen_ > 0)
    {
      outputRow_ = new (collHeap()) char[outputRowLen_ + 2*WALL_STRING_LEN];
      // remember the pointer to the actually usable
      // buffer, not where the wall starts
      outputRow_ += WALL_STRING_LEN;
      memset(outputRow_, 0, outputRowLen_);
      setUpWall(outputRow_, outputRowLen_);
      invocationInfo_->out().setRowPtr(outputRow_);
    }
  else
    outputRow_ = NULL;

  return LM_OK;
}

LmResult LmRoutineCppObj::invokeRoutine(void *inputRow,
                                        void *outputRow,
                                        ComDiagsArea *da)
{
  // This type of routine does not support the old C interface,
  // must call invokeRoutineMethod instead
  *da << DgSqlCode(-11111)
      << DgString0("Called LmRoutineCppObj::invokeRoutine()");

  return LM_ERR;
}

LmResult LmRoutineCppObj::invokeRoutineMethod(
     /* IN */     tmudr::UDRInvocationInfo::CallPhase phase,
     /* IN */     const char   *serializedInvocationInfo,
     /* IN */     Int32         invocationInfoLen,
     /* OUT */    Int32        *invocationInfoLenOut,
     /* IN */     const char   *serializedPlanInfo,
     /* IN */     Int32         planInfoLen,
     /* IN */     Int32         planNum,
     /* OUT */    Int32        *planInfoLenOut,
     /* IN */     char         *inputParamRow,
     /* IN */     Int32         inputParamRowLen,
     /* OUT */    char         *outputRow,
     /* IN */     Int32         outputRowLen,
     /* IN/OUT */ ComDiagsArea *da)
{
  LmResult result = LM_OK;

  // initialize out parameters
  *invocationInfoLenOut = 0;
  *planInfoLenOut = 0;

  // some parameter checks
  if (invocationInfoLen <= 0 &&
      invocationInfo_ == NULL)
    {
      // we need to have an Invocation info
      *da << DgSqlCode(-LME_OBJECT_INTERFACE_ERROR)
          << DgString0(getNameForDiags())
          << DgString1(tmudr::UDRInvocationInfo::callPhaseToString(
                            tmudr::UDRInvocationInfo::COMPILER_INITIAL_CALL))
          << DgString2("LmRoutineCppObj::invokeRoutineMethod()")
          << DgString3("Missing UDRInvocationInfo");
    }

  try
    {
      if (invocationInfoLen > 0)
        {
          if (invocationInfo_ == NULL)
            invocationInfo_ = new tmudr::UDRInvocationInfo;

          // unpack the invocation info
          invocationInfo_->deserializeObj(serializedInvocationInfo,
                                          invocationInfoLen);
        }

      if (planInfoLen > 0)
        {
          if (!planInfos_.used(planNum))
            planInfos_.insertAt(planNum, new tmudr::UDRPlanInfo(invocationInfo_,
                                                                planNum));

          // unpack the invocation info
          planInfos_[planNum]->deserializeObj(serializedPlanInfo,
                                              planInfoLen);
        }

      // some parameter checks
      if (inputParamRowLen < inputParamRowLen_)
        return LM_ERR;
      // test to do for scalar UDFs
      // if (outputRowLen < invocationInfo_->out().getRecordLength())
      //   return LM_ERR;

      if (inputParamRow && inputParamRowLen_ > 0)
        // copy parameter row
        memcpy(invocationInfo_->par().getRowPtr(), inputParamRow, inputParamRowLen_);

      invocationInfo_->callPhase_ = phase;
      switch (phase)
        {
        case tmudr::UDRInvocationInfo::COMPILER_INITIAL_CALL:
          if (invocationInfo_->getDebugFlags() &
              tmudr::UDRInvocationInfo::PRINT_INVOCATION_INFO_INITIAL)
            invocationInfo_->print();

          if (invocationInfo_->getDebugFlags() &
              tmudr::UDRInvocationInfo::DEBUG_INITIAL_COMPILE_TIME_LOOP)
            if (invocationInfo_->getSessionUser() == ComUser::getRootUserName())
              interfaceObj_->debugLoop();
            else if (da)
              *da << DgSqlCode(1260); // warning, only root user can debug

          interfaceObj_->describeParamsAndColumns(*invocationInfo_);
          break;

        case tmudr::UDRInvocationInfo::COMPILER_DATAFLOW_CALL:
          interfaceObj_->describeDataflowAndPredicates(*invocationInfo_);
          break;

        case tmudr::UDRInvocationInfo::COMPILER_CONSTRAINTS_CALL:
          interfaceObj_->describeConstraints(*invocationInfo_);
          break;

        case tmudr::UDRInvocationInfo::COMPILER_STATISTICS_CALL:
          interfaceObj_->describeStatistics(*invocationInfo_);
          break;

        case tmudr::UDRInvocationInfo::COMPILER_DOP_CALL:
          interfaceObj_->describeDesiredDegreeOfParallelism(
               *invocationInfo_,
               *planInfos_[planNum]);
          break;

        case tmudr::UDRInvocationInfo::COMPILER_PLAN_CALL:
          interfaceObj_->describePlanProperties(*invocationInfo_,
                                                *planInfos_[planNum]);
          break;

        case tmudr::UDRInvocationInfo::COMPILER_COMPLETION_CALL:
          interfaceObj_->completeDescription(*invocationInfo_,
                                             *planInfos_[planNum]);
          if (invocationInfo_->getDebugFlags() &
              tmudr::UDRInvocationInfo::PRINT_INVOCATION_INFO_END_COMPILE)
            {
              invocationInfo_->print();
              printf("\n");
              for (CollIndex i=0; i<planInfos_.getUsedLength(); i++)
                if (planInfos_.used(i))
                  {
                    if (i == planNum)
                      printf("++++++++++ Chosen plan: ++++++++++\n");
                    else
                      printf("-------- Plan not chosen: --------\n");
                    planInfos_[i]->print();
                  }
            }

          break;

        case tmudr::UDRInvocationInfo::RUNTIME_WORK_CALL:
          {
            if (invocationInfo_->getDebugFlags() &
                tmudr::UDRInvocationInfo::PRINT_INVOCATION_INFO_AT_RUN_TIME)
              {
                invocationInfo_->print();
                planInfos_[planNum]->print();
              }

            if ((invocationInfo_->getDebugFlags() &
                 tmudr::UDRInvocationInfo::DEBUG_INITIAL_RUN_TIME_LOOP_ALL) ||
                (invocationInfo_->getDebugFlags() &
                 tmudr::UDRInvocationInfo::DEBUG_INITIAL_RUN_TIME_LOOP_ONE &&
                 invocationInfo_->getMyInstanceNum() == 0))
              interfaceObj_->debugLoop();

            interfaceObj_->processData(*invocationInfo_,
                                       *planInfos_[planNum]);

            if (result == LM_OK)
              {
                if (invocationInfo_->getDebugFlags() & tmudr::UDRInvocationInfo::TRACE_ROWS)
                  printf("(%d) Emitting EOD\n",
                         invocationInfo_->getMyInstanceNum());

                // call emitRow to indicate EOD, something the
                // C interface would do inside the UDF
                SQLUDR_Q_STATE qstate = SQLUDR_Q_EOD;

                (*interfaceObj_->emitRowPtr_)(
                     invocationInfo_->out().getRowPtr(),
                     0,
                     &qstate);
              }
          }
          break;

        default:
          *da << DgSqlCode(-11111)
              << DgString0("Invalid call phase in LmRoutineCppObj::invokeRoutineMethod()");

          result = LM_ERR;
          break;
        
        }

      // return length of updated invocation and plan info for
      // compile-time phases
      if (invocationInfo_ &&
          phase < tmudr::UDRInvocationInfo::RUNTIME_WORK_CALL)
        {
          *invocationInfoLenOut = invocationInfo_->serializedLength();
          if (planInfos_.used(planNum))
            *planInfoLenOut = planInfos_[planNum]->serializedLength();
        }
    }
  catch (tmudr::UDRException e)
    {
      // Check the returned SQLSTATE value and raise appropriate
      // SQL code. Valid SQLSTATE values begin with "38" except "38000"
      const char *sqlState = e.getSQLState();

      if ((strncmp(sqlState, "38", 2) == 0) &&
          (strncmp(sqlState, "38000", 5) != 0))
        {
          *da << DgSqlCode(-LME_CUSTOM_ERROR)
              << DgString0(e.getMessage().c_str())
              << DgString1(sqlState);
          *da << DgCustomSQLState(sqlState);
        }
      else
        {
          *da << DgSqlCode(-LME_UDF_ERROR)
              << DgString0(invocationInfo_->getUDRName().c_str())
              << DgString1(sqlState)
              << DgString2(e.getMessage().c_str());
        }
      result = LM_ERR;
    }
  catch (...)
    {
      *da << DgSqlCode(-LME_OBJECT_INTERFACE_ERROR)
          << DgString0(getNameForDiags())
          << DgString1(invocationInfo_->callPhaseToString(phase))
          << DgString2("LmRoutineCppObj::invokeRoutineMethod()")
          << DgString3("general exception");
      result = LM_ERR;
    }

  invocationInfo_->callPhase_ =
    tmudr::UDRInvocationInfo::UNKNOWN_CALL_PHASE;

  return result;
}

LmResult LmRoutineCppObj::getRoutineInvocationInfo(
     /* IN/OUT */ char         *serializedInvocationInfo,
     /* IN */     Int32         invocationInfoMaxLen,
     /* OUT */    Int32        *invocationInfoLenOut,
     /* IN/OUT */ char         *serializedPlanInfo,
     /* IN */     Int32         planInfoMaxLen,
     /* IN */     Int32         planNum,
     /* OUT */    Int32        *planInfoLenOut,
     /* IN/OUT */ ComDiagsArea *da)
{
  LmResult result = LM_OK;

  // Retrieve updated invocation and plan info.
  // The invokeRoutineMethod provided the required buffer
  // space, so there is no excuse for having insufficient
  // buffer when calling this, and doing so will raise
  // an exception in the try block below.
  try
    {
      if (invocationInfo_ && invocationInfoMaxLen > 0)
        {
          char *tempiibuf = serializedInvocationInfo;
          int tempiilen   = invocationInfoMaxLen;
          *invocationInfoLenOut = invocationInfo_->serialize(
               tempiibuf, tempiilen);
        }
      else
        *invocationInfoLenOut = 0;

      if (planInfos_.used(planNum) && planInfoMaxLen > 0)
        {
          char *temppibuf = serializedPlanInfo;
          int temppilen   = planInfoMaxLen;
          *planInfoLenOut = planInfos_[planNum]->serialize(
               temppibuf, temppilen);
        }
      else
        *planInfoLenOut = 0;
    }
  catch (tmudr::UDRException e)
    {
      // this UDRException is generated by Trafodion code and
      // it is an internal error to fail serializing the structs,
      // even though the user might have caused it by corrupting
      // these structs
      *da << DgSqlCode(-LME_OBJECT_INTERFACE_ERROR)
          << DgString0(getNameForDiags())
          << DgString1(invocationInfo_->callPhaseToString(invocationInfo_->getCallPhase()))
          << DgString2("LmRoutineCppObj::getRoutineInvocationInfo()")
          << DgString3(e.getMessage().c_str());
      result = LM_ERR;
    }
  catch (...)
    {
      *da << DgSqlCode(-LME_OBJECT_INTERFACE_ERROR)
          << DgString0(getNameForDiags())
          << DgString1(invocationInfo_->callPhaseToString(invocationInfo_->getCallPhase()))
          << DgString2("LmRoutineCppObj::getRoutineInvocationInfo()")
          << DgString3("general exception");
      result = LM_ERR;
    }

  return result;
}

LmResult LmRoutineCppObj::setFunctionPtrs(SQLUDR_GetNextRow getNextRowPtr,
                                          SQLUDR_EmitRow emitRowPtr,
                                          ComDiagsArea *da)
{
  interfaceObj_->getNextRowPtr_ = getNextRowPtr;
  interfaceObj_->emitRowPtr_    = emitRowPtr;

  return LM_OK;
}

void LmRoutineCppObj::setUpWall(char *userBuf, int userBufLen)
{
  memcpy(userBuf - WALL_STRING_LEN, WALL_STRING, WALL_STRING_LEN);
  memcpy(userBuf + userBufLen, WALL_STRING, WALL_STRING_LEN);
}

LmResult LmRoutineCppObj::validateWall(char *userBuf,
                                       int userBufLen,
                                       ComDiagsArea *da,
                                       const char *bufferName)
{
  if (memcmp(userBuf - WALL_STRING_LEN, WALL_STRING, WALL_STRING_LEN) != 0)
    {
      if (da)
        *da << DgSqlCode(LME_BUFFER_OVERWRITE)
            << DgString0(invocationInfo_->getUDRName().data())
            << DgString1(bufferName)
            << DgString2("beginning");
      else
        throw tmudr::UDRException(
             38900,
             "UDR %s overwrote space before its %s buffer",
             invocationInfo_->getUDRName().data(),
             bufferName);
    }

  if (memcmp(userBuf + userBufLen, WALL_STRING, WALL_STRING_LEN) != 0)
    {
      if (da)
        *da << DgSqlCode(LME_BUFFER_OVERWRITE)
            << DgString0(invocationInfo_->getUDRName().data())
            << DgString1(bufferName)
            << DgString2("end");
      else
        throw tmudr::UDRException(
             38900,
             "UDR %s overwrote space after its %s buffer",
             invocationInfo_->getUDRName().data(),
             bufferName);
    }

  return LM_OK;
}

LmResult LmRoutineCppObj::validateWalls(ComDiagsArea *da)
{
  LmResult result = LM_OK;

  /* not using walls for input tables at the moment
  if (numInputTables_ > 0)
    {
      for (int i=0; i<numInputTables_; i++)
        if (validateWall(inputRows_[i],
                         inputRowLen_,
                         da,
                         (i == 0? "first input table" :
                          (i == 1? "second input table" :
                           "third or subsequent input table"))) != LM_OK)
          result = LM_ERR;
    }
  */

  if (validateWall(outputRow_, outputRowLen_, da, "output row buffer") != LM_OK)
    result = LM_ERR;

  return result;
}

LmResult LmRoutineCppObj::handleFinalCall(ComDiagsArea *diagsArea)
{
  // C++ routines deallocate the interface objects, which will
  // call user code, and therefore could raise an exception.
  // Call the dealloc method before calling the destructor,
  // so that we can handle any errors or exceptions.
  return dealloc(diagsArea);
}