/**********************************************************************
// @@@ 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 @@@
**********************************************************************/
/* -*-C++-*-
******************************************************************************
*
* File:         ExSequenceFunction.cpp
* RCS:          $Id
* Description:  ExSequenceFunction class Implementation
* Created:      9/11/98
* Modified:     $Author
* Language:     C++
* Status:       $State
*
*
*
*
******************************************************************************
*/

#include "Platform.h"


// Includes
//
#include "SQLTypeDefs.h"
#include "exp_clause.h"
#include "exp_attrs.h"
#include "ExpPCode.h"
#include "ExpSequenceFunction.h" // <--- See here for comments.

// ExpSequenceFunction::ExpSequenceFunction
//
// Constructs an ExpSequenceFunction object
//
// IN     : oper_type - The type of clause, must be ITM_OFFSET
// IN     : arity     - The number of input arguments
// IN     : space     - Memory allocator.
// EFFECTS: Calls the base class constructor
// PRECOND: The oper_type is equal to ITM_OFFSET.
//        : The arity doesn't exceed MAX_OPERANDS.
//        : The attributes pointer is valid.
//        : The space object is valid.
// PSTCOND: ExpSequenceFunction is constructed.
//
ExpSequenceFunction::ExpSequenceFunction
(OperatorTypeEnum oper_type, Int32 arity, Int32 index,
 Attributes ** attr, Space * space)
  : ex_function_clause(oper_type, arity, attr, space), offsetIndex_(index), flags_(0) {
};

// ExpSequenceFunction::ExpSequenceFunction
//
// Pseudo Constructor for getting VTable
//
// EFFECTS: None
//
ExpSequenceFunction::ExpSequenceFunction() {;};

// ExpSequenceFunction::pack
//
// Packs an ExpSequenceFunction object
//
// IN     : space - The memory allocator.
// RETURN : the offset withing space of the packed object.
// EFFECTS: Pointers are changed to offsets within space.
// PRECOND: Space is a valid space object.
Long ExpSequenceFunction::pack(void * space) {
  // Since ExpSequenceFunction has no private data, the pack_clause
  // helper of the ex_clause class can be used to pack this
  // class.
  //
  return packClause(space, sizeof(ExpSequenceFunction));
}  

ex_expr::exp_return_type ExpSequenceFunction::pCodeGenerate(Space *space, UInt32 f) 
{

  if(isAnyOperandNullable()) 
    return ex_clause::pCodeGenerate(space, f);

  if(getNumOperands() != 2 && getNumOperands() != 3)
    return ex_clause::pCodeGenerate(space, f);

  if(!nullRowIsZero())
    return ex_clause::pCodeGenerate(space, f);

  if(!isLeading() || (winSize() != 0))
    return ex_clause::pCodeGenerate(space, f);

  AttributesPtr *attrs = getOperand();
  Lng32 fsDataType = attrs[1]->getDatatype();
  Lng32 length = attrs[1]->getLength();
  
  if(fsDataType != REC_BIN64_SIGNED || length != 8)
    return ex_clause::pCodeGenerate(space, f);

  if(getNumOperands() == 3) {
    fsDataType = attrs[2]->getDatatype();
    length = attrs[2]->getLength();

    if(fsDataType != REC_BIN32_SIGNED || length != 4)
      return ex_clause::pCodeGenerate(space, f);
  }

  // If we get to this point, we have decided to generate PCode for this
  // particular sequence function operation.
  //
  PCIList code(space);

  // Generate pre clause PCI's
  //
  PCode::preClausePCI(this, code);

  if(getNumOperands() == 2) {
    Int32 index = offsetIndex_;
  
       
    // The 1st operand is a pointer to the function.
    // The 2nd operand is a pointer the Tcb to get to the history buffer.
    // The 3rd operand is the immediate index value.
    // The 4th operand is the memory location for the target.
    // The 5th operand is the memory location for the source.
    //
    AML aml(PCIT::IPTR, 
            PCIT::IPTR, 
            PCIT::IBIN32S,
            PCIT::getMemoryAddressingMode(attrs[0]->getDatatype()),
            PCIT::getMemoryAddressingMode(attrs[1]->getDatatype()));

    OL ol((Int64)isOLAP(), (Int64)0, index, 
          attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
          attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset());

    // Add the OFFSET instruction.
    //
    PCI pci(PCIT::Op_OFFSET, aml, ol);
    code.append(pci);
  } else {
    // The 1st operand is a pointer to the function.
    // The 2nd operand is a pointer the Tcb to get to the history buffer.
    // The 3rd operand is the memory location for the index value.
    // The 4th operand is the memory location for the target.
    // The 5th operand is the memory location for the source.
    //
    AML aml(PCIT::IPTR,
            PCIT::IPTR,
            PCIT::getMemoryAddressingMode(attrs[2]->getDatatype()),
            PCIT::getMemoryAddressingMode(attrs[0]->getDatatype()),
            PCIT::getMemoryAddressingMode(attrs[1]->getDatatype()));

    OL ol((Int64)(isOLAP()), (Int64)0,
          attrs[2]->getAtp(), attrs[2]->getAtpIndex(), attrs[2]->getOffset(),
          attrs[0]->getAtp(), attrs[0]->getAtpIndex(), attrs[0]->getOffset(),
          attrs[1]->getAtp(), attrs[1]->getAtpIndex(), attrs[1]->getOffset());

    // Add the OFFSET instruction.
    //
    PCI pci(PCIT::Op_OFFSET, aml, ol);
    code.append(pci);
  }
  
  // Generate post clause PCI's
  //
  PCode::postClausePCI(this, code);

  setPCIList(code.getList());
  return ex_expr::EXPR_OK;
}

// ExpSequenceFunction::eval
//
// Implment sequence functions...
//
// IN     : op_data      - output/input vector
// IN     : heap         - not used
// IN     : comDiagsArea - not used
// RETURN : ex_expr::EXPR_OK is no errors
// PRECOND: The op_data vector points to the NULL/VARCHAR and data.
//
ex_expr::exp_return_type ExpSequenceFunction::eval(char *op_data[],
						   CollHeap *heap,
						   ComDiagsArea **diagsArea) {
  
  // Get a handle on the operands so they can be queried for
  // NULL and VARCHAR -ness.
  //
  AttributesPtr *attrs = getOperand();

  // Get the pointer to the index data. If this clause has three operands
  // then the index is given by the last operand. Otherwise, the index
  // is a constant set in the clause.
  //
  Int32 index;
  if(getNumOperands() >= 3) {
    if(attrs[2]->getNullFlag() && !op_data[-2 * MAX_OPERANDS + 2])
      index = -1;
    else
      index = *((Int32 *)op_data[2]);
  }
  else
    index = offsetIndex_;

  // Lookup the indexed row in the history buffer. Compute pointers
  // to the attribute data, null indicator, and varchar indicator.
  //
  char *srcData = NULL;
  UInt32 srcLen = 0;
  char *srcNull = NULL;
  char *srcVC   = NULL;
  Int32 rc=0;

  {
    char *row = (*GetRow_)(GetRowData_, index, isLeading(), winSize(), rc);

    if(rc == -1)
      {
        ExRaiseSqlError(heap, diagsArea, EXE_HISTORY_BUFFER_TOO_SMALL);
        return ex_expr::EXPR_ERROR;
      }
    if(row) 
      {
        srcData = row + attrs[1]->getOffset();
        if(attrs[1]->getVCIndicatorLength() > 0)
          srcVC = row + attrs[1]->getVCLenIndOffset();
        if(attrs[1]->getNullFlag())
          srcNull = row + attrs[1]->getNullIndOffset();

        srcLen = getOperand(1)->getLength(srcVC);
      } else {
          if(getNumOperands() == 4) {
  
             srcData = op_data[3];
             srcLen = getOperand(3)->getLength(op_data[-MAX_OPERANDS+3]);
             srcNull = NULL;
          }
      }
  }

  // Is the source null? There are two reaons the source data can be null:
  // 1. The row does not exist in the history buffer (srcData == NULL)
  // 2. The data exist but is itself NULL (srcNull == 0xFFFF)
  //
  Int32 srcIsNull = (srcData ? 0 : 1);
  if(srcData && srcNull)
    srcIsNull = *((unsigned short*)(srcNull)) == 0xFFFFU;

  // Get the pointer to the start of the result data.
  //
  char *dstData = op_data[0];
  char *dstNull = op_data[-2 * MAX_OPERANDS + 0];
  char *dstVC   = op_data[- MAX_OPERANDS];

  if (rc == -3 && !srcData )
  {
    *((unsigned short*)dstNull) = 0xFFFFU;
    return ex_expr::EXPR_OK;
  }
  // Copy the source data to the destination data.
  //
  if(srcIsNull)
    {
      if(nullRowIsZero() || (rc == -2)) {
        switch (getOperand(1)->getDatatype()) {
        case REC_BIN16_UNSIGNED:
        case REC_BIN16_SIGNED: 
        {
          // hiding code from code coverag tool-- 
          short value = 0;
          str_cpy_all(dstData, (char *) &value, sizeof(value));
          break;
        }
        case REC_BIN32_SIGNED:
        case REC_BIN32_UNSIGNED:
        {
          Lng32 value = 0;
          str_cpy_all(dstData, (char *) &value, sizeof(value));
          break;
        }
        case REC_BIN64_SIGNED:
        {
          Int64 value = 0;
          str_cpy_all(dstData, (char *) &value, sizeof(value));
          break;
        }
        case REC_IEEE_FLOAT32:
        {
          float value = 0;
          str_cpy_all(dstData, (char *) &value, sizeof(value));
          break;
        }
        case REC_IEEE_FLOAT64:
        {
          double value = 0;
          str_cpy_all(dstData, (char *) &value, sizeof(value));
          break;
        }
        default:
        {
          Lng32 value = 0;
          if (convDoIt((char *)&value,
                       sizeof(value),
                       REC_BIN32_SIGNED,
                       0,
                       0,
                       dstData,
                       getOperand(1)->getLength(),
                       getOperand(1)->getDatatype(),
                       getOperand(1)->getPrecision(),
                       getOperand(1)->getScale(),
                       NULL, 0, heap, diagsArea,
                       CONV_UNKNOWN) != ex_expr::EXPR_OK) {
            return ex_expr::EXPR_ERROR;
          }

          break;
        }
        }

        if(attrs[0]->getNullFlag())
          *((short*)dstNull) = 0x0000;

      } else {
        *((unsigned short*)dstNull) = 0xFFFFU;
      }
    }
  else
    {
      Int32 len = attrs[0]->getLength();
      str_cpy_all(dstData, srcData, attrs[0]->getLength());
      if (attrs[1]->getVCIndicatorLength() > 0)
           getOperand(0)->setVarLength(srcLen, dstVC);
           //getOperand(0)->setVarLength(getOperand(1)->getLength(srcVC), dstVC);
      if(attrs[0]->getNullFlag())
        *((short*)dstNull) = 0x0000;
    }

  // Return all OK...
  //
  return ex_expr::EXPR_OK;
};