/**********************************************************************
// @@@ 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:         LmExpr.cpp
* Description:  Code to generate ItemExpr trees that convert UDR parameters
*               to/from formats acceptable as input to the Language Manager
* Created:      10/28/2000
* Language:     C++
*
******************************************************************************
*/

/*
  About this code:
    
  The Language Manager does not accept all SQL datatypes. When a SQL
  datatype is not acceptable as input/output to LM, the value must be
  converted to a "normalized form" before/after LM sees it. The functions
  in this file create ItemExpr trees that convert values to/from LM-normal
  form. 

  The two main functions are CreateLmInputExpr() and CreateLmOutputExpr().
  Both can be called during codegen for a UDR node to create ItemExpr 
  trees that convert to/from LM-normal form. See comments at the beginning
  of those functions for more detail. 

  This file begins with many static helper functions.

*/

#include "LmExpr.h"
#include "ItemExpr.h"
#include "ItemFunc.h"
#include "NAType.h"
#include "ItemNAType.h"
#include "CharType.h"
#include "NumericType.h"
#include "parser.h"
#include "CmpContext.h"
#include "DatetimeType.h"

// Fix for bug 3137.
// The following global is defined in SqlParserGlobals.h file and is set
// when parsing result set proxy statement. It is used in allowing a
// result set column type of VARCHAR(0) in proxy statement(resulting from
// an empty string in SELECT statement).
// It gets reset after initial parsing of the proxy statement but we need to
// set it again during codegen time to avoid error 3003.
extern THREAD_P NABoolean inRSProxyStmt;

// Helper function to create an ItemExpr tree from a scalar
// expression string.
static ItemExpr *ParseExpr(NAString &s, CmpContext &c, ItemExpr &ie)
{
  ItemExpr *result = NULL;
  Parser parser(&c);
  result = parser.getItemExprTree(s.data(), s.length(),
                                  CharInfo::UTF8
                                  , 1, &ie);
  return result;
}

//
// Helper function to get the maximum number of characters required
// to represent a value of a given NAType.
//
static Lng32 GetDisplayLength(const NAType &t)
{
  Lng32 result = t.getDisplayLength(
    t.getFSDatatype(),
    t.getNominalSize(),
    t.getPrecision(),
    t.getScale(),
    0);
  return result;
}

//
// Helper function to create an ItemExpr tree that converts a SQL
// value to a SQL string without null terminator.
//
static ItemExpr *CreateLmString(ItemExpr &source,
                                const NAType &sourceType,
                                ComRoutineLanguage language,
                                ComRoutineParamStyle style,
                                CmpContext *cmpContext)
{
  //
  // We want an ItemExpr that converts any value X to a 
  // string. We will use this SQL syntax:
  //
  //   cast(X as {CHAR|VARCHAR}(N) CHARACTER SET ISO88591)
  //
  // where N is the max display length of X. The datatype of the
  // result will be CHAR(N) or VARCHAR(N) depending on the language.
  //
  ItemExpr *result = NULL;
  NAMemory *h = cmpContext->statementHeap();
  
  Lng32 maxLength = GetDisplayLength(sourceType);
  char buf[100];
  sprintf(buf, "%d", maxLength);

  NAString *s = new (h) NAString("cast (@A1 as ", h);
  if (style == COM_STYLE_JAVA_CALL)
    (*s) += "VARCHAR(";
  else
    (*s) += "CHAR(";
  (*s) += buf;
  (*s) += ") CHARACTER SET ISO88591);";
  
  result = ParseExpr(*s, *cmpContext, source);

  return result;
}

//
// Helper function to create an ItemExpr tree that converts
// a SQL value, represented by the source ItemExpr, to the
// target type.
//
static ItemExpr *CreateCastExpr(ItemExpr &source, const NAType &target,
                                CmpContext *cmpContext)
{
  ItemExpr *result = NULL;
  NAMemory *h = cmpContext->statementHeap();
  
  NAString *s;
  s = new (h) NAString("cast(@A1 as ", h);

  (*s) += target.getTypeSQLname(TRUE);

  if (!target.supportsSQLnull())
    (*s) += " NOT NULL";

  (*s) += ");";
  
  result = ParseExpr(*s, *cmpContext, source);

  return result;
}

// Helper function to create an ItemExpr tree that converts a string
// to an INTERVAL value. This expression tree is necessary because
// SQL/MX will only convert arbitrary strings to INTERVALs when moving
// values into the CLI via an input expression.
static ItemExpr *CreateIntervalExpr(ItemExpr &source, const NAType &target,
                                    CmpContext *cmpContext)
{
  // Our goal is to create the following expression tree. Assume "@A1"
  // is the input string
  //
  // case substring(@A1 from 1 for 1)
  // when '-' then
  //   cast(-cast(substring(@A1 from 2) as interval year) as interval year)
  // else
  //   cast(@A1 as interval year)
  // end

  ItemExpr *result = NULL;
  NAMemory *h = cmpContext->statementHeap();

  NAString T = target.getTypeSQLname(TRUE);
  if (!target.supportsSQLnull())
    T += " NOT NULL";
  
  NAString *s = new (h) NAString("case substring(@A1 from 1 for 1) ", h);
  (*s) += "when '-' then cast(-cast(substring(@A1 from 2) as ";
  (*s) += T;
  (*s) += ") as ";
  (*s) += T;
  (*s) += ") else cast(@A1 as ";
  (*s) += T;
  (*s) += ") end;";

  result = ParseExpr(*s, *cmpContext, source);

  return result;
}

//---------------------------------------------------------------------------
// CreateLmInputExpr
// 
// Creates an ItemExpr tree to convert a SQL value to LM-normal form.
// Returns the tree in newExpr. Right now LM-normal form is:
// - SQL native format for
//       * binary precision integers
//       * floating point and
//       * Character types(char and varchar)
// - non-null terminated C string(CHAR(N) or VARCHAR(N)) for everything else
//---------------------------------------------------------------------------
LmExprResult CreateLmInputExpr(const NAType &formalType,
                               ItemExpr &actualValue,
                               ComRoutineLanguage language,
                               ComRoutineParamStyle style,
                               CmpContext *cmpContext,
                               ItemExpr *&newExpr)
{
  LmExprResult result = LmExprOK;
  NABoolean isResultSet = FALSE;

  if (LmTypeIsString(formalType, language, style, isResultSet))
  {
    if (formalType.getTypeQualifier() == NA_CHARACTER_TYPE)
    {
      newExpr = &actualValue;
    }
    else
    {
      newExpr = CreateLmString(actualValue, formalType, language, style, cmpContext);
    }
  }
  else
  {
    newExpr = CreateCastExpr(actualValue, formalType, cmpContext);
  }

  if (newExpr == NULL)
  {
    result = LmExprError;
  }

  return result;
}

//---------------------------------------------------------------------------
// CreateLmOutputExpr
// 
// Creates an ItemExpr tree to convert a value in LM-normal form to 
// SQL native format. Returns the tree in outputValue. The expressions
// will be used by a UDR TCB to process a UDR output value in the UDR
// server's reply buffer.
// 
// One other side-effect of this function:
// This function determines the SQL type that corresponds to LM-normal
// form and creates an NATypeToItem instance of that type. This NATypeToItem
// represents a UDR output value that has just come back from the UDR server
// in a reply buffer. A UDR TCB must convert the value from LM-normal format
// to the SQL formal parameter type. To allow codegen for the UDR TCB to set
// up the map table correctly, we return the NATypeToItem instance in 
// normalizedValue.
//---------------------------------------------------------------------------
LmExprResult CreateLmOutputExpr(const NAType &formalType,
                                ComRoutineLanguage language,
                                ComRoutineParamStyle style,
                                CmpContext *cmpContext,
                                ItemExpr *&normalizedValue,
                                ItemExpr *&outputValue,
                                NABoolean isResultSet)
{
  LmExprResult result = LmExprError;
  normalizedValue = NULL;
  outputValue = NULL;
  NAMemory *h = cmpContext->statementHeap();
  NAType *replyType = NULL;
  NABoolean isString = LmTypeIsString(formalType, language, style, isResultSet);

  if (isString &&
      (formalType.getTypeQualifier() != NA_CHARACTER_TYPE))
  {
    if (isResultSet || style != COM_STYLE_JAVA_CALL)
    {
      Lng32 maxLength = GetDisplayLength(formalType);
      replyType = new (h) SQLChar(h, maxLength);
    }
    else
    {
      Lng32 maxLength = GetDisplayLength(formalType);
      replyType = new (h) SQLVarChar(h, maxLength);
    }
  }
  else
  {
    replyType = formalType.newCopy(h);
  }
  
  if (replyType)
  {
    if (style == COM_STYLE_JAVA_CALL)
    {
      // $$$$ TBD: let's assume all CALL statement parameters are
      // nullable for now, until we are sure UDR server's null
      // processing is correct for both nullable and non-nullable
      // types.
      replyType->setNullable(TRUE);
    }
    else
      // Copy the nullability attribute from the formal type
      replyType->setNullable(formalType);

    normalizedValue = new (h) NATypeToItem(replyType->newCopy(h));
    if (normalizedValue)
    {
      // Note that we didn't apply cast expr for CHAR and VARCHAR for
      // IN params. But we need to have cast expr for OUT params, even
      // though there is no actual casting of data, because we need to
      // move data from buffer to up Queue in the root node.

      if (formalType.getTypeQualifier() == NA_INTERVAL_TYPE && isString)
        outputValue = CreateIntervalExpr(*normalizedValue,
                                         formalType,
                                         cmpContext);
      else
      {
    	// Fix for bug 3137.
    	// Set the parser flag to allow VARCHAR(0) as proxy column type
    	// before entering the parser. See comment above for more detail.
    	if (isResultSet && formalType.getTypeQualifier() == NA_CHARACTER_TYPE)
    	   inRSProxyStmt = TRUE;
        outputValue = CreateCastExpr(*normalizedValue,
                                     formalType,
                                     cmpContext);
        inRSProxyStmt = FALSE;
      }

      if (outputValue)
      {
        result = LmExprOK;
      }
      else
      {
        normalizedValue = NULL;
      }
    }
  }
  
  return result;
}

//---------------------------------------------------------------------------
// LM type info functions
//
// LM-required types have certain attributes that are of interest during
// codegen for a UDR operator. The following functions all return TRUE
// or FALSE depending on whether a given NAType has one of these attributes.
//---------------------------------------------------------------------------

//
// This function returns TRUE if LM wants values of the
// specified type t to be converted to/from C strings. The only 
// SQL types that do not need to be converted to C strings are:
// 
//  INT, TINYINT, SMALLINT, LARGEINT, FLOAT, REAL, DOUBLE PRECISION, BOOLEAN
//
// because these types map to Java primitive types:
//
//  INT -> int
//  TINYINT -> byte
//  SMALLINT -> short
//  LARGEINT -> long
//  FLOAT -> float or double
//  REAL -> float
//  DOUBLE PREC -> double
//  BOOLEAN -> byte
//
// For the object-oriented Java and C++ parameter styles, we represent
// intervals as a signed numeric of 2, 4, or 8 bytes, in the other
// parameter styles it is represented as a string.
//
//  INTERVAL -> short or int or long or string
//
// Note: When changing this, a change in file ../sqludr/sqludr.cpp
//       may be required as well (and other places, of course)
NABoolean LmTypeIsString(const NAType &t,
                         ComRoutineLanguage language,
                         ComRoutineParamStyle style,
                         NABoolean isResultSet)
{
  NABoolean result = TRUE;
  
  if (t.getTypeQualifier() == NA_NUMERIC_TYPE)
  {
    const NumericType &nt = *((const NumericType *) &t);
    if (nt.isExact())
    {
      if (nt.binaryPrecision())
      {
        // INT
        // SMALLINT
        // LARGEINT
        result = FALSE;
      }
      else if (nt.isDecimal())
      {
        // DECIMAL
        if (isResultSet)
          result = FALSE;
        else
          result = TRUE;
      }
      else
      {
        // NUMERIC
        // Cases to consider
        // * SPJ result sets: LM format is internal format
        // * Java call style: LM format is a string
        // * Bignum: LM format is a string
        // * C/C++ routines or Java object style: LM format is internal format
        if (isResultSet)
          result = FALSE;
        else if (language != COM_LANGUAGE_C &&
                 language != COM_LANGUAGE_CPP &&
                 style != COM_STYLE_JAVA_OBJ)
          result = TRUE;
        else if (nt.isBigNum())
          result = TRUE;
        else
          result = FALSE;
      }
    }
    else
    {
      // FLOAT (8-byte value)
      // REAL (4-byte value)
      // DOUBLE PRECISION = FLOAT(52)
      result = FALSE;
    }
  }
  else if (t.getTypeQualifier() == NA_INTERVAL_TYPE &&
           (style == COM_STYLE_JAVA_OBJ ||
            style == COM_STYLE_CPP_OBJ))
  {
    // in the object-oriented styles, use the native
    // interval representation as a number
    result = FALSE;
  }
  else if (t.getTypeQualifier() == NA_BOOLEAN_TYPE)
    result = FALSE;

  return result;
}

//
// This function returns TRUE if LM requires a precision setting 
// for the given type.
//
NABoolean LmTypeSupportsPrecision(const NAType &t)
{
  NABoolean result = FALSE;
  NABuiltInTypeEnum q = t.getTypeQualifier();
  
  switch (q)
  {
    case NA_NUMERIC_TYPE:
    {
      const NumericType &nt = *((const NumericType *) &t);
      if (nt.isExact() && !nt.binaryPrecision())
      {
        // NUMERIC, DECIMAL
        result = TRUE;
      }
    }
    break;

    case NA_DATETIME_TYPE:
    {
      // For DATE, TIME, and TIMESTAMP we store the datetime code as
      // precision. The datetime code indicates whether the type is
      // DATE, TIME, or TIMESTAMP.
      result = TRUE;
    }
    break;
  }
  
  return result;
}

// This function returns TRUE if LM requires a scale setting 
// for the given type.
NABoolean LmTypeSupportsScale(const NAType &t)
{
  NABoolean result = FALSE;
  NABuiltInTypeEnum q = t.getTypeQualifier();
  
  switch (q)
  {
    case NA_NUMERIC_TYPE:
    {
      const NumericType &nt = *((const NumericType *) &t);
      if (nt.isExact() && !nt.binaryPrecision())
      {
        // NUMERIC, DECIMAL
        result = TRUE;
      }
    }
    break;

    case NA_DATETIME_TYPE:
    {
      const DatetimeType &dt = *((const DatetimeType *) &t);
      DatetimeType::Subtype subtype = dt.getSubtype();
      if (subtype == DatetimeType::SUBTYPE_SQLTime ||
          subtype == DatetimeType::SUBTYPE_SQLTimestamp)
      {
        // For TIME and TIMESTAMP we store fractional precision in the
        // scale field
        result = TRUE;
      }
    }
    break;
  }
  
  return result;
}

// This function returns TRUE if LM considers the given type to
// be an "LM object type". 
//
// *** NOT IMPLEMENTED YET ***
// Semantics for LM object types are not completely defined so
// we cannot implement this function yet.
NABoolean LmTypeIsObject(const NAType &t)
{
  NABoolean result = FALSE;
  return result;
}