/************************************************************************
// @@@ 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:         <file>
 * RCS:          $Id: exp_clause_derived.cpp,v 1.44 1998/07/20 07:24:44  Exp $
 * Description:  
 *
 *
 * Created:      7/10/95
 * Modified:     $ $Date: 1998/07/20 07:24:44 $ (GMT)
 * Language:     C++
 * Status:       $State: Exp $
 *
 *
 *
 *
 *****************************************************************************
 */
#ifndef EXP_CLAUSE_DERIVED_H
#define EXP_CLAUSE_DERIVED_H

#include "SqlExpDllDefines.h"
#include "exp_clause.h"
#include "exp_like.h"
#include <byteswap.h>

#pragma warning ( disable : 4251 )

#define instrAndText(a) a, #a

/////////////////////////////////////////
// Class ex_aggregate_clause            //
/////////////////////////////////////////
class SQLEXP_LIB_FUNC  ex_aggregate_clause : public ex_clause {
public:
  // Construction
  //
  NA_EIDPROC ex_aggregate_clause(){};
  NA_EIDPROC ex_aggregate_clause(OperatorTypeEnum oper_type,
				 short num_operands,
				 Attributes ** attr,
				 Space * space);


  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const { return 0; };
  NA_EIDPROC Int32 isNullRelevant() const { return 0; };


  // Execution
  //
  NA_EIDPROC Int32 isEvalRelevant() const { return 1; };
  NA_EIDPROC virtual ex_expr::exp_return_type init();
  NA_EIDPROC virtual ex_expr::exp_return_type eval(char *op_data[],
						   CollHeap * = 0,
						   ComDiagsArea** = 0);  

  // Fixup
  //
  NA_EIDPROC Long pack(void *);
  NA_EIDPROC virtual ex_expr::exp_return_type 
    pCodeGenerate(Space *space, UInt32 flags);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(1,getClassVersionID());
    ex_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }
  // ---------------------------------------------------------------------
};

class SQLEXP_LIB_FUNC  ex_aggr_one_row_clause : public ex_aggregate_clause {
public:	
  // Construction
  //
  NA_EIDPROC ex_aggr_one_row_clause(){};
  NA_EIDPROC ex_aggr_one_row_clause(OperatorTypeEnum oper_type,
				    short num_operands,
				    Attributes ** attr,
				    Space * space)
    : ex_aggregate_clause(oper_type, num_operands, attr, space) {};

 
  // Execution
  //
  NA_EIDPROC ex_expr::exp_return_type init();
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0);  

  // Fixup
  //
  NA_EIDPROC ex_expr::exp_return_type 
       pCodeGenerate(Space *space, UInt32 flags);  

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
                                  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(2,getClassVersionID());
    ex_aggregate_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }
  // ---------------------------------------------------------------------
  
private:  
  // set to TRUE, if one row has been processed.
  UInt16           oneRowProcessed_;     // 00-01
  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char             fillers_[14];          // 02-15

};

class SQLEXP_LIB_FUNC  ex_aggr_any_true_max_clause : public ex_aggregate_clause {
public:	
  // Construction
  //
  NA_EIDPROC ex_aggr_any_true_max_clause(){};
  NA_EIDPROC ex_aggr_any_true_max_clause(OperatorTypeEnum oper_type,
					 short num_operands,
					 Attributes ** attr,
					 Space * space)
    : ex_aggregate_clause(oper_type, num_operands, attr, space) {};
    
 
  // Execution
  //
  NA_EIDPROC ex_expr::exp_return_type init();
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0);  

  // Fixup
  //
  NA_EIDPROC ex_expr::exp_return_type 
       pCodeGenerate(Space *space, UInt32 flags);

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
                                  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(2,getClassVersionID());
    ex_aggregate_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }
  // ---------------------------------------------------------------------

private:  
  // set to TRUE, is a null value is seen while processing this
  // aggregate.
  UInt16           nullSeen_;            // 00-01
  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char             fillers_[14];          // 02-15

};

class SQLEXP_LIB_FUNC  ex_aggr_min_max_clause : public ex_aggregate_clause {
public:	
  // Construction
  //
  NA_EIDPROC ex_aggr_min_max_clause(){};
  NA_EIDPROC ex_aggr_min_max_clause(OperatorTypeEnum oper_type,
				    short num_operands,
				    Attributes ** attr,
				    Space * space)
    : ex_aggregate_clause(oper_type, num_operands, attr, space) {};

 
  // Execution
  //
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0);  

  // Fixup
  //
  NA_EIDPROC ex_expr::exp_return_type 
       pCodeGenerate(Space *space, UInt32 flags);

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(2,getClassVersionID());
    ex_aggregate_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }

private:  
  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char             fillers_[16];          // 00-15

  // ---------------------------------------------------------------------
};

class SQLEXP_LIB_FUNC  ExFunctionGrouping : public ex_aggregate_clause {
public:
  ExFunctionGrouping(OperatorTypeEnum oper_type,
                     short num_operands,
                     Attributes ** attr,
                     Int16 rollupGroupIndex,
                     Space * space)
    : ex_aggregate_clause(oper_type, num_operands, attr, space),
    rollupGroupIndex_(rollupGroupIndex),
    rollupNull_(0)
      {};
  
  ExFunctionGrouping(){};

  ex_expr::exp_return_type init();
  ex_expr::exp_return_type eval(char *op_data[], 
                                CollHeap* = 0, 
                                ComDiagsArea** = 0);  

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
                                  Int32 clauseNum, char * constsArea);

  Int16 getRollupGroupIndex() { return rollupGroupIndex_; }
  void setRollupNull(short v) {  rollupNull_ = v; }

private:
  Int16 rollupGroupIndex_;
  Int16 rollupNull_;
  
  char fillers_[60];
  // ---------------------------------------------------------------------
};

class SQLEXP_LIB_FUNC  ex_pivot_group_clause : public ex_aggregate_clause {
public:	
  // Construction
  //
  NA_EIDPROC ex_pivot_group_clause(){};
  NA_EIDPROC ex_pivot_group_clause(OperatorTypeEnum oper_type,
                                   short num_operands,
                                   Attributes ** attr,
                                   char * delim,
                                   Lng32 maxLen,
                                   NABoolean isOrderBy,
                                   Space * space)
    : ex_aggregate_clause(oper_type, num_operands, attr, space),
    maxLen_(maxLen)
    {
      setOrderBy(isOrderBy);
      strcpy(delim_, delim);
    }

 
  // Execution
  //
  ex_expr::exp_return_type init();
  ex_expr::exp_return_type eval(char *op_data[],
                                CollHeap * = 0,
                                ComDiagsArea ** = 0);

  NA_EIDPROC Int32 isNullInNullOut() const { return 0; };
  NA_EIDPROC Int32 isNullRelevant() const { return 1; };
  
  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
                                  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(2,getClassVersionID());
    ex_aggregate_clause::populateImageVersionIDArray();
  }

  virtual short getClassSize() { return (short)sizeof(*this); }

  NABoolean orderBy()   
  { return (flags_ & ORDER_BY) != 0;}
  void setOrderBy(NABoolean v)      
  { (v ? flags_ |= ORDER_BY : flags_ &= ~ORDER_BY); }

  NABoolean ovflWarn()   
  { return (flags_ & OVFL_WARN) != 0;}
  void setOvflWarn(NABoolean v)      
  { (v ? flags_ |= OVFL_WARN : flags_ &= ~OVFL_WARN); }

private:  
  enum
  {
    ORDER_BY   = 0x0001,
    OVFL_WARN = 0x0002
  };

  Lng32 currPos_;
  Lng32 currTgtLen_;
  char delim_[112];
  Lng32 maxLen_;
  UInt32 flags_;

  // ---------------------------------------------------------------------
};
  
/////////////////////////////////////////
// Class arith_clause                  //
/////////////////////////////////////////

// (these codes must remain invariant across future versions)
enum ArithInstruction { 
  ADD_BIN16S_BIN16S_BIN16S      =0, 
  ADD_BIN16S_BIN16S_BIN32S      =1, 
  ADD_BIN16S_BIN32S_BIN32S      =2, 
  ADD_BIN32S_BIN16S_BIN32S      =3, 
  ADD_BIN32S_BIN32S_BIN32S      =4,
  ADD_BIN64S_BIN64S_BIN64S      =5,
  ADD_BIN32S_BIN64S_BIN64S      =6, 
  ADD_BIN64S_BIN32S_BIN64S      =7,
  ADD_BIN16U_BIN16U_BIN16U      =8, 
  ADD_BIN16U_BIN16U_BIN32U      =9, 
  ADD_BIN16U_BIN32U_BIN32U      =10, 
  ADD_BIN32U_BIN16U_BIN32U      =11, 
  ADD_BIN32U_BIN32U_BIN32U      =12,
  ADD_BPINTU_BIN64S_BIN64S      =13, 
  ADD_BIN64S_BPINTU_BIN64S      =14, 
  ADD_BIN32U_BIN64S_BIN64S      =15, 
  ADD_BIN64S_BIN32U_BIN64S      =16,

  ADD_FLOAT32_FLOAT32_FLOAT32   =17, 
  ADD_FLOAT64_FLOAT64_FLOAT64   =18,
  ADD_DATETIME_INTERVAL_DATETIME=19, 
  ADD_INTERVAL_DATETIME_DATETIME=20,
    
  SUB_BIN16S_BIN16S_BIN16S      =21, 
  SUB_BIN16S_BIN16S_BIN32S      =22, 
  SUB_BIN16S_BIN32S_BIN32S      =23, 
  SUB_BIN32S_BIN16S_BIN32S      =24, 
  SUB_BIN32S_BIN32S_BIN32S      =25, 
  SUB_BIN64S_BIN64S_BIN64S      =26,
  SUB_BIN16U_BIN16U_BIN16U      =27, 
  SUB_BIN16U_BIN16U_BIN32U      =28, 
  SUB_BIN16U_BIN32U_BIN32U      =29, 
  SUB_BIN32U_BIN16U_BIN32U      =30, 
  SUB_BIN32U_BIN32U_BIN32U      =31,
  SUB_FLOAT32_FLOAT32_FLOAT32   =32, 
  SUB_FLOAT64_FLOAT64_FLOAT64   =33,
  SUB_DATETIME_INTERVAL_DATETIME=34, 
  SUB_DATETIME_DATETIME_INTERVAL=35,
    
  MUL_BIN16S_BIN16S_BIN16S      =36, 
  MUL_BIN16S_BIN16S_BIN32S      =37, 
  MUL_BIN16S_BIN32S_BIN32S      =38, 
  MUL_BIN32S_BIN16S_BIN32S      =39, 
  MUL_BIN32S_BIN32S_BIN32S      =40, 
  MUL_BIN64S_BIN64S_BIN64S      =41,
  MUL_BIN16U_BIN16U_BIN16U      =42, 
  MUL_BIN16U_BIN16U_BIN32U      =43, 
  MUL_BIN16U_BIN32U_BIN32U      =44, 
  MUL_BIN32U_BIN16U_BIN32U      =45, 
  MUL_BIN32U_BIN32U_BIN32U      =46,
  MUL_FLOAT32_FLOAT32_FLOAT32   =47, 
  MUL_FLOAT64_FLOAT64_FLOAT64   =48,
    
  DIV_BIN16S_BIN16S_BIN16S      =49, 
  DIV_BIN16S_BIN16S_BIN32S      =50, 
  DIV_BIN16S_BIN32S_BIN32S      =51, 
  DIV_BIN32S_BIN16S_BIN32S      =52, 
  DIV_BIN32S_BIN32S_BIN32S      =53, 
  DIV_BIN64S_BIN64S_BIN64S      =54,
  DIV_BIN16U_BIN16U_BIN16U      =55, 
  DIV_BIN16U_BIN16U_BIN32U      =56, 
  DIV_BIN16U_BIN32U_BIN32U      =57, 
  DIV_BIN32U_BIN16U_BIN32U      =58, 
  DIV_BIN32U_BIN32U_BIN32U      =59,
  DIV_FLOAT64_FLOAT64_FLOAT64   =60,
    
  ADD_COMPLEX                   =61, 
  SUB_COMPLEX                   =62, 
  MUL_COMPLEX                   =63, 
  DIV_COMPLEX                   =64,
  ARITH_NOT_SUPPORTED           =65,
  MUL_BIN16S_BIN32S_BIN64S      =66,
  MUL_BIN32S_BIN16S_BIN64S      =67,
  MUL_BIN32S_BIN32S_BIN64S      =68,

  DIV_BIN64S_BIN64S_BIN64S_ROUND=69,

  NEGATE_BOOLEAN                =70
};

class SQLEXP_LIB_FUNC  ex_arith_clause : public ex_clause {

  typedef struct {
    OperatorTypeEnum op;
    short type_op1; // left operand
    short type_op2; // right operand
    short type_op0; // result
    ArithInstruction instruction;
    const char * instrStr;
  } ArithInstrStruct;
  
public:

  // Construction
  //
  NA_EIDPROC ex_arith_clause(){};
  NA_EIDPROC ex_arith_clause(OperatorTypeEnum oper_type,
			     Attributes ** attr,
			     Space * space,
			     short arithRoundingMode,
			     NABoolean divToDownscale);
  NA_EIDPROC ex_arith_clause(clause_type type,
			     OperatorTypeEnum oper_type,
			     Attributes ** attr,
			     Space * space);

 
  // Accessors
  //
  ArithInstruction getInstruction()
  {
    if (getInstrArrayIndex() >= 0)
      return getInstruction(getInstrArrayIndex());
    else
      return ARITH_NOT_SUPPORTED;
  };
  void setInstruction();
  void setInstruction(OperatorTypeEnum op,
                      Attributes * attr1,
                      Attributes * attr2,
                      Attributes * result);
  
  short isArithSupported(OperatorTypeEnum op,
                         Attributes * attr1,
                         Attributes * attr2,
                         Attributes * result);

  static const ArithInstrStruct arithInstrInfo[];
  static const char * getInstructionStr(Lng32 index) 
  { return arithInstrInfo[index].instrStr;}
  static const ArithInstruction getInstruction(Lng32 index) 
  { return arithInstrInfo[index].instruction;}

  Lng32 findIndexIntoInstrArray(ArithInstruction ci);

  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const { return 1; };
  NA_EIDPROC Int32 isNullRelevant() const { return 1; };

  // Execution
  //
  NA_EIDPROC Int32 isEvalRelevant() const { return 1; };
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0);  

  NA_EIDPROC ex_expr::exp_return_type evalUnsupportedOperations(
       char *op_data[],
       CollHeap * heap,
       ComDiagsArea ** diagsArea);  

  // Fixup
  //
  NA_EIDPROC Long pack(void *);
  NA_EIDPROC ex_expr::exp_return_type pCodeGenerate(Space *space,
						    UInt32 flags);

  // pcode for unary arith operators, like NEGATE.
  ex_expr::exp_return_type unaryArithPCodeGenerate
    (Space *space, UInt32 flags);

  NA_EIDPROC ex_expr::exp_return_type fixup(Space * space = 0,
					    CollHeap * exHeap = 0,
					    char * constants_area = 0,
					    char * temps_area = 0,
					    char * persistentArea = 0,
					    short fixupConstsAndTemps = 0,
					    NABoolean spaceCompOnly = FALSE);

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(1,getClassVersionID());
    ex_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }
  // ---------------------------------------------------------------------
  
private:
  enum
  {
    DIV_TO_DOWNSCALE = 0x01
  };

  char filler[4];             // 00-03

  char arithRoundingMode_;               // 04-04
  char flags_;                           // 05-05
 
  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char             fillers_[18];          // 06-23

  NA_EIDPROC const ArithInstrStruct * getMatchingRow(OperatorTypeEnum op,
						    short datatype1,
						    short datatype2,
						    short resulttype);

  NA_EIDPROC const ArithInstruction computeCaseIndex(OperatorTypeEnum op,
						     Attributes * attr1,
						     Attributes * attr2,
						     Attributes * result);

  NA_EIDPROC NABoolean getDivToDownscale()   
  { return (flags_ & DIV_TO_DOWNSCALE) != 0;}
  NA_EIDPROC void setDivToDownscale(NABoolean v)      
  { (v ? flags_ |= DIV_TO_DOWNSCALE : flags_ &= ~DIV_TO_DOWNSCALE); }
  
};

class SQLEXP_LIB_FUNC  ex_arith_sum_clause : public ex_arith_clause {
public:
  NA_EIDPROC ex_arith_sum_clause() {};
  NA_EIDPROC ex_arith_sum_clause(OperatorTypeEnum oper_type,
				 Attributes ** attr,
				 Space * space);


  NA_EIDPROC ex_expr::exp_return_type pCodeGenerate(Space *space, 
						    UInt32 flags);

  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const { return 0; };
  NA_EIDPROC ex_expr::exp_return_type processNulls(char *op_data[],
  						   CollHeap * = 0,
						   ComDiagsArea ** = 0);
  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(1,getClassVersionID());
    ex_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }
  // ---------------------------------------------------------------------
  
private:   

  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char             fillers_[8];          // 00-07

};

class SQLEXP_LIB_FUNC  ex_arith_count_clause : public ex_arith_clause {
public:
  NA_EIDPROC ex_arith_count_clause() {};
  NA_EIDPROC ex_arith_count_clause(OperatorTypeEnum oper_type,
				   Attributes ** attr,
				   Space * space);


  NA_EIDPROC ex_expr::exp_return_type pCodeGenerate(Space *space
						    , UInt32 flags);

  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const { return 0; };
  NA_EIDPROC ex_expr::exp_return_type processNulls(char *op_data[],
  						   CollHeap * = 0,
						   ComDiagsArea ** = 0);
  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(2,getClassVersionID());
    ex_arith_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }
  // ---------------------------------------------------------------------
  
private:   

  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char             fillers_[8];          // 00-07

};

/////////////////////////////////////////
// Class bool_clause                   //
/////////////////////////////////////////
class SQLEXP_LIB_FUNC  ex_bool_clause : public ex_clause {
public:
  // Construction
  //
  NA_EIDPROC ex_bool_clause(){};
  NA_EIDPROC ex_bool_clause(OperatorTypeEnum oper_type,
			    Attributes ** attr,
			    Space * space);


  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const { return 0; };
  NA_EIDPROC Int32 isNullRelevant() const { return 0; };

  // Execution
  //
  NA_EIDPROC Int32 isEvalRelevant() const { return 1; };
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0);  

  // Fixup
  //
  NA_EIDPROC Long pack(void *);
  NA_EIDPROC ex_expr::exp_return_type 
    pCodeGenerate(Space *space, UInt32 flags);

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(1,getClassVersionID());
    ex_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }

private:
  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char             fillers_[8];          // 00-07

  // ---------------------------------------------------------------------
};

////////////////////////////////////////////////
// Class bool_result_clause
///////////////////////////////////////////////
class SQLEXP_LIB_FUNC  bool_result_clause : public ex_clause {
public:
  // Construction
  //
  NA_EIDPROC bool_result_clause(){};
  NA_EIDPROC bool_result_clause(OperatorTypeEnum oper_type, Attributes ** attr,
				Space * space);


  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const { return 0; };
  NA_EIDPROC Int32 isNullRelevant() const { return 0; };

  // Execution
  //
  NA_EIDPROC Int32 isEvalRelevant() const { return 1; };
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0);

  // Fixup
  //
  NA_EIDPROC Long pack(void *);
  NA_EIDPROC ex_expr::exp_return_type 
    pCodeGenerate(Space *space, UInt32 flags);

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(1,getClassVersionID());
    ex_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }

private:
  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char             fillers_[8];          // 00-07

  // ---------------------------------------------------------------------
};

/////////////////////////////////////////
// Class branch_clause                 //
/////////////////////////////////////////
class SQLEXP_LIB_FUNC  ex_branch_clause : public ex_clause {
public:
  // Construction
  //
  NA_EIDPROC ex_branch_clause() : saved_next_clause(NULL), branch_clause(NULL)
    {};
  NA_EIDPROC ex_branch_clause(OperatorTypeEnum oper_type,
			      Attributes ** attr,
			      Space * space);

  NA_EIDPROC ex_branch_clause(OperatorTypeEnum oper_type,
			      Space * space);


  // Accessors
  //
  //NA_EIDPROC inline void set_branch_clause(ex_clause*);
  inline void set_branch_clause(ex_clause *clause_)
  {
    branch_clause = clause_;
  };
  //NA_EIDPROC inline void set_saved_next(ex_clause*);
  inline void set_saved_next(ex_clause *clause_)
  {
    saved_next_clause = clause_;
  };
  NA_EIDPROC inline ex_clause * get_branch_clause()
  {
    return branch_clause;
  };
  //NA_EIDPROC inline ex_clause * get_saved_next();
  inline ex_clause * get_saved_next()
  {
    return saved_next_clause;
  };

  // This is a branching clause
  //
  NA_EIDPROC Int32 isBranchingClause() const { return 1; };

  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const { return 0; };
  NA_EIDPROC Int32 isNullRelevant() const { return 0; };

  // Execution
  //
  NA_EIDPROC Int32 isEvalRelevant() const { return 1; };
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0);

  // Fixup
  //
  NA_EIDPROC Long pack(void *);
  NA_EIDPROC Lng32 unpack(void *, void * reallocator);
  NA_EIDPROC ex_expr::exp_return_type fixup(Space * space = 0,
                                            CollHeap * exHeap = 0,
                                            char * constants_area = 0,
                                            char * temps_area = 0,
                                            char * persistentArea = 0,
                                            short = 0,
					    NABoolean spaceCompOnly = FALSE);
  NA_EIDPROC ex_expr::exp_return_type 
    pCodeGenerate(Space *space, UInt32 flags);

  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(1,getClassVersionID());
    ex_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }
  // ---------------------------------------------------------------------

private:   
  ExClausePtr      saved_next_clause;    // 00-07
  ExClausePtr      branch_clause;        // 08-15

  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char             fillers_[8];          // 16-23

};

//inline void ex_branch_clause::set_branch_clause(ex_clause *clause_){
//  branch_clause = clause_;
//};

//inline void ex_branch_clause::set_saved_next(ex_clause *clause_){
//  saved_next_clause = clause_;
//};

//inline ex_clause * ex_branch_clause::get_branch_clause(){
//  return branch_clause;
//};

//inline ex_clause * ex_branch_clause::get_saved_next(){
//  return saved_next_clause;
//};

#define myDefine(a) #a

/////////////////////////////////////////
// Class comp_clause
/////////////////////////////////////////
// (these codes must remain invariant across future versions)
enum CompInstruction { 
  EQ_BIN16S_BIN16S    =0,
  EQ_BIN16S_BIN32S    =1, 
  EQ_BIN16S_BIN16U    =2, 
  EQ_BIN16S_BIN32U    =3,
  NE_BIN16S_BIN16S    =4, 
  NE_BIN16S_BIN32S    =5, 
  NE_BIN16S_BIN16U    =6, 
  NE_BIN16S_BIN32U    =7,
  LT_BIN16S_BIN16S    =8, 
  LT_BIN16S_BIN32S    =9, 
  LT_BIN16S_BIN16U    =10, 
  LT_BIN16S_BIN32U    =11,
  LE_BIN16S_BIN16S    =12, 
  LE_BIN16S_BIN32S    =13, 
  LE_BIN16S_BIN16U    =14, 
  LE_BIN16S_BIN32U    =15,
  GT_BIN16S_BIN16S    =16, 
  GT_BIN16S_BIN32S    =17, 
  GT_BIN16S_BIN16U    =18, 
  GT_BIN16S_BIN32U    =19,
  GE_BIN16S_BIN16S    =20, 
  GE_BIN16S_BIN32S    =21, 
  GE_BIN16S_BIN16U    =22, 
  GE_BIN16S_BIN32U    =23,
    
  EQ_BIN32S_BIN16S    =24, 
  EQ_BIN32S_BIN32S    =25, 
  EQ_BIN32S_BIN16U    =26, 
  EQ_BIN32S_BIN32U    =27,
  NE_BIN32S_BIN16S    =28, 
  NE_BIN32S_BIN32S    =29, 
  NE_BIN32S_BIN16U    =30, 
  NE_BIN32S_BIN32U    =31,
  LT_BIN32S_BIN16S    =32, 
  LT_BIN32S_BIN32S    =33, 
  LT_BIN32S_BIN16U    =34, 
  LT_BIN32S_BIN32U    =35,
  LE_BIN32S_BIN16S    =36, 
  LE_BIN32S_BIN32S    =37, 
  LE_BIN32S_BIN16U    =38, 
  LE_BIN32S_BIN32U    =39,
  GT_BIN32S_BIN16S    =40, 
  GT_BIN32S_BIN32S    =41, 
  GT_BIN32S_BIN16U    =42, 
  GT_BIN32S_BIN32U    =43,
  GE_BIN32S_BIN16S    =44, 
  GE_BIN32S_BIN32S    =45, 
  GE_BIN32S_BIN16U    =46, 
  GE_BIN32S_BIN32U    =47,
    
  EQ_BIN64S_BIN64S    =48,
  NE_BIN64S_BIN64S    =49,
  LT_BIN64S_BIN64S    =50,
  LE_BIN64S_BIN64S    =51,
  GT_BIN64S_BIN64S    =52,
  GE_BIN64S_BIN64S    =53,
    
  EQ_BIN16U_BIN16S    =54, 
  EQ_BIN16U_BIN32S    =55, 
  EQ_BIN16U_BIN16U    =56, 
  EQ_BIN16U_BIN32U    =57,
  NE_BIN16U_BIN16S    =58, 
  NE_BIN16U_BIN32S    =59, 
  NE_BIN16U_BIN16U    =60, 
  NE_BIN16U_BIN32U    =61,
  LT_BIN16U_BIN16S    =62, 
  LT_BIN16U_BIN32S    =63, 
  LT_BIN16U_BIN16U    =64, 
  LT_BIN16U_BIN32U    =65,
  LE_BIN16U_BIN16S    =66, 
  LE_BIN16U_BIN32S    =67, 
  LE_BIN16U_BIN16U    =68, 
  LE_BIN16U_BIN32U    =69,
  GT_BIN16U_BIN16S    =70, 
  GT_BIN16U_BIN32S    =71, 
  GT_BIN16U_BIN16U    =72, 
  GT_BIN16U_BIN32U    =73,
  GE_BIN16U_BIN16S    =74, 
  GE_BIN16U_BIN32S    =75, 
  GE_BIN16U_BIN16U    =76, 
  GE_BIN16U_BIN32U    =77,
    
  EQ_BIN32U_BIN16S    =78, 
  EQ_BIN32U_BIN32S    =79, 
  EQ_BIN32U_BIN16U    =80, 
  EQ_BIN32U_BIN32U    =81,
  NE_BIN32U_BIN16S    =82, 
  NE_BIN32U_BIN32S    =83, 
  NE_BIN32U_BIN16U    =84, 
  NE_BIN32U_BIN32U    =85,
  LT_BIN32U_BIN16S    =86, 
  LT_BIN32U_BIN32S    =87, 
  LT_BIN32U_BIN16U    =88, 
  LT_BIN32U_BIN32U    =89,
  LE_BIN32U_BIN16S    =90, 
  LE_BIN32U_BIN32S    =91, 
  LE_BIN32U_BIN16U    =92, 
  LE_BIN32U_BIN32U    =93,
  GT_BIN32U_BIN16S    =94, 
  GT_BIN32U_BIN32S    =95, 
  GT_BIN32U_BIN16U    =96, 
  GT_BIN32U_BIN32U    =97,
  GE_BIN32U_BIN16S    =98, 
  GE_BIN32U_BIN32S    =99, 
  GE_BIN32U_BIN16U    =100, 
  GE_BIN32U_BIN32U    =101,
    
  EQ_DECU_DECU        =102, 
  NE_DECU_DECU        =103, 
  LT_DECU_DECU        =104, 
  LE_DECU_DECU        =105, 
  GT_DECU_DECU        =106,
  GE_DECU_DECU        =107,
    
  EQ_DECS_DECS        =108, 
  NE_DECS_DECS        =109, 
  LT_DECS_DECS        =110, 
  LE_DECS_DECS        =111, 
  GT_DECS_DECS        =112,
  GE_DECS_DECS        =113,
    
  EQ_FLOAT32_FLOAT32  =114,
  NE_FLOAT32_FLOAT32  =115,
  LT_FLOAT32_FLOAT32  =116,
  LE_FLOAT32_FLOAT32  =117,
  GT_FLOAT32_FLOAT32  =118,
  GE_FLOAT32_FLOAT32  =119,
    
  EQ_FLOAT64_FLOAT64  =120,
  NE_FLOAT64_FLOAT64  =121,
  LT_FLOAT64_FLOAT64  =122,
  LE_FLOAT64_FLOAT64  =123,
  GT_FLOAT64_FLOAT64  =124,
  GE_FLOAT64_FLOAT64  =125,
    
  EQ_DATETIME_DATETIME=126,
  NE_DATETIME_DATETIME=127,
  LT_DATETIME_DATETIME=128,
  LE_DATETIME_DATETIME=129,
  GT_DATETIME_DATETIME=130,
  GE_DATETIME_DATETIME=131,
    
  EQ_ASCII_F_F        =132, 
  NE_ASCII_F_F        =133, 
  LT_ASCII_F_F        =134, 
  LE_ASCII_F_F        =135, 
  GT_ASCII_F_F        =136,
  GE_ASCII_F_F        =137,
    
  EQ_UNICODE_F_F      =138, 
  NE_UNICODE_F_F      =139, 
  LT_UNICODE_F_F      =140, 
  LE_UNICODE_F_F      =141, 
  GT_UNICODE_F_F      =142, 
  GE_UNICODE_F_F      =143,
  
  ASCII_COMP          =144,   
  UNICODE_COMP        =145,
    
  COMP_COMPLEX        =146,

  EQ_ASCII_COMP       =147,
  NE_ASCII_COMP       =148,
  LT_ASCII_COMP       =149,
  LE_ASCII_COMP       =150,
  GT_ASCII_COMP       =151,
  GE_ASCII_COMP       =152,

  EQ_BLOB        =153, 
  NE_BLOB        =154, 
  LT_BLOB        =155, 
  LE_BLOB        =156, 
  GT_BLOB        =157,
  GE_BLOB        =158,

  EQ_BIN64U_BIN64U    =159,
  EQ_BIN64U_BIN64S    =160,
  EQ_BIN64S_BIN64U    =161,
  NE_BIN64U_BIN64U    =162,
  NE_BIN64U_BIN64S    =163,
  NE_BIN64S_BIN64U    =164,
  LT_BIN64U_BIN64U    =165,
  LT_BIN64U_BIN64S    =166,
  LT_BIN64S_BIN64U    =167,
  LE_BIN64U_BIN64U    =168,
  LE_BIN64U_BIN64S    =169,
  LE_BIN64S_BIN64U    =170,
  GT_BIN64U_BIN64U    =171,
  GT_BIN64U_BIN64S    =172,
  GT_BIN64S_BIN64U    =173,
  GE_BIN64U_BIN64U    =174,
  GE_BIN64U_BIN64S    =175,
  GE_BIN64S_BIN64U    =176,
    
  EQ_BOOL_BOOL        =177,
  NE_BOOL_BOOL        =178,

  // tinyint operations
  EQ_BIN8S_BIN8S      =179,
  EQ_BIN8U_BIN8U      =180,
  NE_BIN8S_BIN8S      =181,
  NE_BIN8U_BIN8U      =182,
  LT_BIN8S_BIN8S      =183,
  LT_BIN8U_BIN8U      =184,
  LE_BIN8S_BIN8S      =185,
  LE_BIN8U_BIN8U      =186,
  GT_BIN8S_BIN8S      =187,
  GT_BIN8U_BIN8U      =188,
  GE_BIN8S_BIN8S      =189,
  GE_BIN8U_BIN8U      =190,

  COMP_NOT_SUPPORTED  =191
};

class SQLEXP_LIB_FUNC  ex_comp_clause : public ex_clause {

  typedef struct {
    OperatorTypeEnum op;
    short type_op1; // left operand
    short type_op2; // right operand
    CompInstruction instruction;
    const char * instrStr;
  } CompInstrStruct;
  
public:

  // Construction
  //
  NA_EIDPROC ex_comp_clause(): flags_(0)
  {  };
  NA_EIDPROC ex_comp_clause(OperatorTypeEnum oper_type,
			    Attributes ** attr,
			    Space * space,
			    ULng32 flags_);


  // Accessors
  //
  NA_EIDPROC inline CompInstruction getInstruction()
  {
    if (getInstrArrayIndex() >= 0)
      return getInstruction(getInstrArrayIndex());
    else
      return COMP_NOT_SUPPORTED;
  };

  NA_EIDPROC void setInstruction();
  NA_EIDPROC void setInstruction(OperatorTypeEnum op,
				 Attributes * attr1,
				 Attributes * attr2);

  NA_EIDPROC short isComparisonSupported(OperatorTypeEnum op,
					 Attributes * attr1,
					 Attributes * attr2);

  static const CompInstrStruct compInstrInfo[];
  static const char * getInstructionStr(Lng32 index) 
  { return compInstrInfo[index].instrStr;}
  static const CompInstruction getInstruction(Lng32 index) 
  { return compInstrInfo[index].instruction;}

  Lng32 findIndexIntoInstrArray(CompInstruction ci);

  void setRollupColumnNum(Int16 v) {rollupColumnNum_ = v;}
  Int16 getRollupColumnNum() { return rollupColumnNum_; }

  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const { return 0; };
  NA_EIDPROC Int32 isNullRelevant() const { return 1; };
  NA_EIDPROC ex_expr::exp_return_type processNulls(char *op_data[],
  						   CollHeap * = 0,
						   ComDiagsArea ** = 0);

  // Execution
  //
  NA_EIDPROC Int32 isEvalRelevant() const { return 1; };
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0); 

  NA_EIDPROC ex_expr::exp_return_type evalUnsupportedOperations(
       char *op_data[],
       CollHeap * heap,
       ComDiagsArea ** diagsArea);  

  // Fixup
  //
  NA_EIDPROC Long pack(void *);
  NA_EIDPROC ex_expr::exp_return_type 
    pCodeGenerate(Space *space, UInt32 flags);
  NA_EIDPROC ex_expr::exp_return_type fixup(Space * space = 0,
					    CollHeap * exHeap = 0,
					    char * constants_area = 0,
					    char * temps_area = 0,
					    char * persistentArea = 0,
					    short fixupConstsAndTemps = 0,
					    NABoolean spaceCompOnly = FALSE);

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(1,getClassVersionID());
    ex_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }

  NA_EIDPROC  NABoolean getCollationEncodeComp() 
  {
    return ((flags_ & COLLATION_ENCODE_COMP) != 0);
  }
  NA_EIDPROC  void setCollationEncodeComp(NABoolean v) 
  {
    (v) ? flags_ |= COLLATION_ENCODE_COMP: flags_ &= ~COLLATION_ENCODE_COMP;
  }


  // ---------------------------------------------------------------------

private:  

  enum
  {
    COLLATION_ENCODE_COMP          = 0x0001
  };

  Int32            filler0;           // 00-03
  Int16		   flags_; //04-05		   

  // see optimizer/ItemLog.h, class BiRelat
  Int16 rollupColumnNum_;   //06-07

  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char             fillers_[24];          // 08-31
  NA_EIDPROC ex_expr::exp_return_type processResult(Int32 compare_code, Lng32* result,
					      CollHeap *heap,
					      ComDiagsArea** diagsArea);
  
  NA_EIDPROC const CompInstrStruct * getMatchingRow(OperatorTypeEnum op,
						   short datatype1,
						   short datatype2);

  NA_EIDPROC const CompInstruction computeCaseIndex(OperatorTypeEnum op,
						    Attributes * attr1,
						    Attributes * attr2);
};

  
/////////////////////////////////////////
// Class ex_conv_clause
/////////////////////////////////////////
enum ConvInstruction {
  // (these codes must remain invariant across future versions)
  CONV_BIN16S_BPINTU                   =0,  
  CONV_BIN16S_BIN16S                   =1,    
  CONV_BIN16S_BIN16U                   =2,   
  CONV_BIN16S_BIN32S                   =3,  
  CONV_BIN16S_BIN32U                   =4,
  CONV_BIN16S_BIN64S                   =5,   
  CONV_BIN16S_DECS                     =6,
  CONV_BIN16S_DECU                     =7,
  CONV_BIN16S_FLOAT32                  =8,  
  CONV_BIN16S_FLOAT64                  =10,
  CONV_BIN16S_ASCII                    =13, 
  CONV_BPINTU_BPINTU                   =14,

  CONV_BIN16U_BPINTU                   =15, 
  CONV_BIN16U_BIN16S                   =16, 
  CONV_BIN16U_BIN16U                   =17,   
  CONV_BIN16U_BIN32S                   =18, 
  CONV_BIN16U_BIN32U                   =19, 
  CONV_BIN16U_BIN64S                   =20,   
  CONV_BIN16U_DECS                     =21, 
  CONV_BIN16U_FLOAT32                  =22,
  CONV_BIN16U_FLOAT64                  =23, 
  CONV_BIN16U_ASCII                    =25,

  CONV_BIN32S_BPINTU                   =26, 
  CONV_BIN32S_BIN16S                   =27, 
  CONV_BIN32S_BIN16U                   =28,   
  CONV_BIN32S_BIN32S                   =29, 
  CONV_BIN32S_BIN32U                   =30, 
  CONV_BIN32S_BIN64S                   =31,   
  CONV_BIN32S_DECS                     =32, 
  CONV_BIN32S_DECU                     =33, 
  CONV_BIN32S_FLOAT32                  =34,  
  CONV_BIN32S_FLOAT64                  =35, 
  CONV_BIN32S_ASCII                    =38,

  CONV_BIN32U_BPINTU                   =39, 
  CONV_BIN32U_BIN16S                   =40, 
  CONV_BIN32U_BIN16U                   =41,   
  CONV_BIN32U_BIN32S                   =42, 
  CONV_BIN32U_BIN32U                   =43, 
  CONV_BIN32U_BIN64S                   =44,   
  CONV_BIN32U_DECS                     =45, 
  CONV_BIN32U_FLOAT32                  =46,
  CONV_BIN32U_FLOAT64                  =47, 
  CONV_BIN32U_ASCII                    =49,

  CONV_BIN64S_BPINTU                   =50, 
  CONV_BIN64S_BIN16S                   =51, 
  CONV_BIN64S_BIN16U                   =52,   
  CONV_BIN64S_BIN32S                   =53, 
  CONV_BIN64S_BIN32U                   =54, 
  CONV_BIN64S_BIN64S                   =55, 
  CONV_BIN64S_DECS                     =56, 
  CONV_BIN64S_DECU                     =57, 
  CONV_BIN64S_FLOAT32                  =58,  
  CONV_BIN64S_FLOAT64                  =59, 
  CONV_BIN64S_ASCII                    =62,
 
  // all conversions from DECU are handled by the appropriate
  // CONV_DECS_* (compare exp_fixup.cpp)
  // conversions to BIN16S, BIN16U are handled
  // by CONV_DECS_BIN32S and CONV_DECS_BIN32U respectively
  // conversions to BPINT are hadled by CONV_DECS_BIN32U

  CONV_DECS_BIN32S                     =63,
  CONV_DECS_BIN32U                     =64, 
  CONV_DECS_BIN64S                     =65, 
  CONV_DECS_DECS                       =66,
  CONV_DECS_DECU                       =67, 
  CONV_DECS_FLOAT32                    =68, 
  CONV_DECS_FLOAT64                    =69,
  CONV_DECS_ASCII                      =70,

  CONV_FLOAT32_BPINTU                  =71, 
  CONV_FLOAT32_BIN16S                  =72, 
  CONV_FLOAT32_BIN16U                  =73,  
  CONV_FLOAT32_BIN32S                  =74, 
  CONV_FLOAT32_BIN32U                  =75, 
  CONV_FLOAT32_BIN64S                  =76,  
  CONV_FLOAT32_DECS                    =77, 
  CONV_FLOAT32_DECU                    =78, 
  CONV_FLOAT32_FLOAT32                 =79, 
  CONV_FLOAT32_FLOAT64                 =80, 
  CONV_FLOAT32_ASCII                   =81,

  CONV_FLOAT64_BPINTU                  =82, 
  CONV_FLOAT64_BIN16S                  =83, 
  CONV_FLOAT64_BIN16U                  =84,  
  CONV_FLOAT64_BIN32S                  =85, 
  CONV_FLOAT64_BIN32U                  =86, 
  CONV_FLOAT64_BIN64S                  =87,  
  CONV_FLOAT64_DECS                    =88, 
  CONV_FLOAT64_DECU                    =89, 
  CONV_FLOAT64_FLOAT32                 =90, 
  CONV_FLOAT64_FLOAT64                 =91, 
  CONV_FLOAT64_ASCII                   =92,

  CONV_DECLS_DECLS                     =104, 
  CONV_DECLS_ASCII                     =105,

  // interval conversions

  // The representation of an interval depends only on the end field;
  // conversions between interval datatypes with the same end field
  // are done via the numeric cases.  When end fields differ, conversion
  // implies multiplication or division by a constant (e.g. converting
  // years to months implies multiplication by 12).  Note that the
  // Generator ordinarily generates arithmetic operators to do this
  // scaling; the exception is in key building where we need to catch
  // overflow and truncations from this scaling operation.  It's simpler
  // to catch it as part of convDoIt() processing.

  CONV_INTERVALY_INTERVALMO            =106,
  
  CONV_INTERVALMO_INTERVALY            =107,

  CONV_INTERVALD_INTERVALH             =108,  
  CONV_INTERVALD_INTERVALM             =109,  
  CONV_INTERVALD_INTERVALS             =110,

  CONV_INTERVALH_INTERVALD             =111,  
  CONV_INTERVALH_INTERVALM             =112,  
  CONV_INTERVALH_INTERVALS             =113,

  CONV_INTERVALM_INTERVALD             =114,  
  CONV_INTERVALM_INTERVALH             =115,  
  CONV_INTERVALM_INTERVALS             =116,

  CONV_INTERVALS_INTERVALD             =117,  
  CONV_INTERVALS_INTERVALH             =118,  
  CONV_INTERVALS_INTERVALM             =119,
  CONV_INTERVALS_INTERVALS_DIV         =120, // second(n) to second(m), n > m
  CONV_INTERVALS_INTERVALS_MULT        =121, // second(n) to second(m), m > n
  CONV_INTERVAL_ASCII                  =122,

  // datetime conversions

  CONV_DATETIME_DATETIME               =123, 
  CONV_DATETIME_ASCII                  =124,

  // character string conversions

  CONV_ASCII_BIN16S                    =125, 
  CONV_ASCII_BIN16U                    =126,    
  CONV_ASCII_BIN32S                    =127, 
  CONV_ASCII_BIN32U                    =128, 
  CONV_ASCII_BIN64S                    =129,
  CONV_ASCII_DEC                       =130,
  CONV_ASCII_FLOAT32                   =131, 
  CONV_ASCII_FLOAT64                   =132,
  CONV_ASCII_DATETIME                  =134,
  CONV_ASCII_INTERVAL                  =135,
  CONV_ASCII_F_F                       =136, 
  CONV_ASCII_F_V                       =137, 
  CONV_ASCII_V_F                       =138,
  CONV_ASCII_V_V                       =139,

// unicode related conversion constants

  CONV_UNICODE_BIN16S                  =140, 
  CONV_UNICODE_BIN16U                  =141,    
  CONV_UNICODE_BIN32S                  =142, 
  CONV_UNICODE_BIN32U                  =143,    
  CONV_UNICODE_BIN64S                  =144,
  CONV_UNICODE_DEC                     =145,
  CONV_UNICODE_FLOAT32                 =146, 
  CONV_UNICODE_FLOAT64                 =147,
  CONV_UNICODE_DATETIME                =149,
  CONV_UNICODE_INTERVAL                =150,

  CONV_BIN16S_UNICODE                  =151, 
  CONV_BIN16U_UNICODE                  =152,    
  CONV_BIN32S_UNICODE                  =153, 
  CONV_BIN32U_UNICODE                  =154,    
  CONV_BIN64S_UNICODE                  =155,
  CONV_DECS_UNICODE                    =156,
  CONV_FLOAT32_UNICODE                 =157, 
  CONV_FLOAT64_UNICODE                 =158,
  CONV_DATETIME_UNICODE                =160,
  CONV_INTERVAL_UNICODE                =161,

  CONV_UNICODE_F_F                     =162, 
  CONV_UNICODE_F_V                     =163, 
  CONV_UNICODE_V_F                     =164,
  CONV_UNICODE_V_V                     =165,
  CONV_UNICODE_F_ASCII_F               =166,
  CONV_UNICODE_V_ASCII_F               =167,
  CONV_UNICODE_F_ASCII_V               =168,
  CONV_UNICODE_V_ASCII_V               =169,

  CONV_UNICODE_F_SJIS_F                =170,
  CONV_UNICODE_V_SJIS_F                =171,
  CONV_UNICODE_F_SJIS_V                =172,
  CONV_UNICODE_V_SJIS_V                =173,

  CONV_SJIS_F_UNICODE_F                =174,
  CONV_SJIS_V_UNICODE_F                =175,
  CONV_SJIS_F_UNICODE_V                =176,
  CONV_SJIS_V_UNICODE_V                =177,

  CONV_UNICODE_F_MBYTE_LOCALE_F        =178, // to multi-byte locale (fixed)
  CONV_UNICODE_F_SBYTE_LOCALE_F        =179, // to single-byte locale (fixed)
  CONV_UNICODE_V_MBYTE_LOCALE_F        =180, // to multi-byte locale (v)
  CONV_UNICODE_V_SBYTE_LOCALE_F        =181, // to single-byte locale (v)

// 6/26/98: added from unicode to ansi varnchar, 
// from ansi varnchar to varnchar, and ansi varnchar to ansi varnchar

  CONV_UNICODE_TO_ANSI_V_UNICODE       =182, 
  CONV_ANSI_V_UNICODE_TO_UNICODE_V     =183, 
  CONV_ANSI_V_UNICODE_TO_ANSI_V_UNICODE=184,

  // convert from ASCII(SQL internal) to ANSI V (ANSI VARCHAR --
  // null terminated string)

  CONV_ASCII_UNICODE_F                 =185, 
  CONV_ASCII_UNICODE_V                 =186, 

  // convert from ASCII(SQL internal) to ANSI V (ANSI VARCHAR --
  // null terminated string)

  CONV_ASCII_TO_ANSI_V                 =187,

  CONV_ANSI_V_TO_ASCII_F               =188,
  CONV_ANSI_V_TO_ASCII_V               =189,
  CONV_ANSI_V_TO_ANSI_V                =190,
    
  CONV_COMPLEX_TO_COMPLEX              =191, 
  CONV_SIMPLE_TO_COMPLEX               =192, 
  CONV_COMPLEX_TO_SIMPLE               =193,

  CONV_NOT_SUPPORTED                   =194, 
  CONV_UNKNOWN_LEFTPAD                 =195, 
  CONV_UNKNOWN                         =196,

  CONV_UNICODE_F_ANSI_V                =197,
  CONV_UNICODE_V_ANSI_V                =198,

  // Big Num related conversions

  CONV_BIN16S_BIGNUMU                  =199,
  CONV_BIN16S_BIGNUM                   =200,
  CONV_BIN16U_BIGNUM                   =201,
  CONV_BIN32S_BIGNUMU                  =202,
  CONV_BIN32S_BIGNUM                   =203,
  CONV_BIN32U_BIGNUM                   =204,
  CONV_BIN64S_BIGNUMU                  =205,
  CONV_BIN64S_BIGNUM                   =206,
  CONV_ASCII_BIGNUM                    =207,
  CONV_UNICODE_BIGNUM                  =208,

  CONV_BIGNUM_BIN16S                   =209,
  CONV_BIGNUM_BIN16U                   =210,
  CONV_BIGNUM_BIN32S                   =211,
  CONV_BIGNUM_BIN32U                   =212,
  CONV_BIGNUM_BIN64S                   =213,
  CONV_BIGNUM_DECS                     =214,
  CONV_BIGNUM_DECU                     =215,
  CONV_BIGNUM_FLOAT32                  =216,
  CONV_BIGNUM_FLOAT64                  =217,
  CONV_BIGNUM_BIGNUM                   =218,
  CONV_BIGNUM_ASCII                    =219,
  CONV_BIGNUM_UNICODE                  =220,

  // Conversions needed for char-type matching rule relaxation
  CONV_ASCII_TO_ANSI_V_UNICODE       =222, 
  CONV_ANSI_V_UNICODE_TO_ASCII_V     =223,
  CONV_ANSI_V_UNICODE_TO_ASCII_F     =224,
  CONV_ANSI_V_UNICODE_TO_UNICODE_F   =225,

  // conversion between tandem and IEEE floats. These are the ONLY supported
  // conversions involving tdm floats. Any other conversion(like int to 
  // tdm_float32, etc) should be first converted to IEEE equivalent and then
  // from IEEE to tdm.

  CONV_FLOAT32TDM_FLOAT32IEEE          =226,
  CONV_FLOAT32TDM_FLOAT64IEEE          =227,
  CONV_FLOAT32TDM_FLOAT32TDM           =228,
  CONV_FLOAT32TDM_FLOAT64TDM           =229,

  CONV_FLOAT64TDM_FLOAT32IEEE          =230,
  CONV_FLOAT64TDM_FLOAT64IEEE          =231,
  CONV_FLOAT64TDM_FLOAT32TDM           =232,
  CONV_FLOAT64TDM_FLOAT64TDM           =233,

  CONV_FLOAT32IEEE_FLOAT32TDM          =234,
  CONV_FLOAT32IEEE_FLOAT64TDM          =235,
  CONV_FLOAT64IEEE_FLOAT32TDM          =236,
  CONV_FLOAT64IEEE_FLOAT64TDM          =237,

  CONV_FLOAT32TDM_ASCII                =238,
  CONV_FLOAT64TDM_ASCII                =239,
  CONV_ASCII_FLOAT32TDM                =240,
  CONV_ASCII_FLOAT64TDM                =241,
  CONV_DECLS_DECU                      =242,

  CONV_BIN64S_DATETIME                 =243,
  CONV_DATETIME_BIN64S                 =244,

  CONV_UCS2_F_SJIS_V                   =245,
  CONV_UCS2_F_UTF8_V                   =246,
  CONV_SJIS_F_UCS2_V                   =247,
  CONV_UTF8_F_UCS2_V                   =248,

  CONV_BLOB_BLOB                       =249,
  CONV_BLOB_ASCII_F                    =250,

  CONV_GBK_F_UTF8_V                    =251,

  // TINYINT conversions
  CONV_BIN8S_BIN8S                     =252,
  CONV_BIN8U_BIN8U                     =253,
  CONV_BIN8S_BIN16S                    =254,
  CONV_BIN8U_BIN16U                    =255,
  CONV_BIN16S_BIN8S                    =256,
  CONV_BIN16U_BIN8U                    =257,
  CONV_BIN16U_BIN8S                    =258,
  CONV_BIN16S_BIN8U                    =259,
  CONV_BIN8U_BIN16S                    =260,
  CONV_BIN8S_BIN32S                    =261,
  CONV_BIN8U_BIN32U                    =262,
  CONV_BIN8S_BIN64S                    =263,
  CONV_BIN8U_BIN64U                    =264,
  CONV_BIN8S_ASCII                     =265,
  CONV_BIN8U_ASCII                     =266,
  CONV_ASCII_BIN8S                     =267,
  CONV_ASCII_BIN8U                     =268,
  
  // boolean conversions
  CONV_BOOL_BOOL                       =269,
  CONV_BOOL_ASCII                      =270,
  CONV_ASCII_BOOL                      =271,

  // unsigned largeint related conversions
  CONV_BIN64S_BIN64U                   =272,
  CONV_BIN64U_BIN64U                   =273,
  CONV_FLOAT32_BIN64U                  =274, 
  CONV_FLOAT64_BIN64U                  =275,
  CONV_BIN64U_BIN64S                   =276,
  CONV_BIN64U_BIGNUM                   =277,
  CONV_BIGNUM_BIN64U                   =278,
  CONV_BIN64U_FLOAT32                  =279,
  CONV_BIN64U_FLOAT64                  =280,
  CONV_BIN64U_ASCII                    =281,
  CONV_ASCII_BIN64U                    =282,

  // more tinyint conversions not handled above. 
  // At runtime, expression code will handle them based on source datatype.
  CONV_NUMERIC_BIN8S                    =283,
  CONV_NUMERIC_BIN8U                    =284,

  CONV_BIN8S_BIN8U                     =285,
  CONV_BIN8U_BIN8S                     =286,

};

class SQLEXP_LIB_FUNC  ex_conv_clause : public ex_clause {

  typedef struct {
    short type_op1; // left operand
    short type_op2; // right operand
    ConvInstruction instruction;
    const char * instrStr;
  } ConvInstrStruct;
  
public:

  // Construction
  //
  NA_EIDPROC ex_conv_clause()
  {
    lastVOAoffset_ = 0;
    lastVcIndicatorLength_ = 0;
    lastNullIndicatorLength_ = 0;
  };
  NA_EIDPROC ex_conv_clause(OperatorTypeEnum oper_type, 
			    Attributes ** attr, 
			    Space * space,
                            short num_operands = 2, 
			    NABoolean checkTruncErr = FALSE,
                            NABoolean reverseDataErrorConversionFlag = FALSE,
                            NABoolean noStringTruncWarnings = FALSE,
                            NABoolean convertToNullWhenErrorFlag = FALSE);


  // Values used for dataConvErrorFlag.
  enum ConvResult {CONV_RESULT_OK = 0,
		   CONV_RESULT_ROUNDED_DOWN = -1,
		   CONV_RESULT_ROUNDED_DOWN_TO_MAX = -2,
		   CONV_RESULT_ROUNDED_UP = 1,
		   CONV_RESULT_ROUNDED_UP_TO_MIN = 2,
		   CONV_RESULT_FAILED = 3,
		   CONV_RESULT_ROUNDED = 4,
                  }
  ;

  // Accessors
  // 
  NA_EIDPROC void setInstruction();

  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const ;

  NA_EIDPROC Int32 isNullRelevant() const { return 1; };
  NA_EIDPROC ex_expr::exp_return_type processNulls(char *op_data[],
  						   CollHeap * = 0,
						   ComDiagsArea ** = 0);

  // Execution
  // 
  NA_EIDPROC Int32 isEvalRelevant() const { return 1; };
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0);  

  // case index get and set
  ConvInstruction getInstruction()
  {
    if (getInstrArrayIndex() >= 0)
      return getInstruction(getInstrArrayIndex());
    else
      return CONV_NOT_SUPPORTED;
  };

  NA_EIDPROC ConvInstruction findInstruction(short sourceType, Lng32 sourceLen,
                                             short targetType, Lng32 targetLen,
                                             Lng32 scaleDifference);

  NABoolean isConversionSupported(short sourceType, Lng32 srcLen, 
                                  short targetType, Lng32 tgtLen);

  static const ConvInstrStruct convInstrInfo[];
  static const char * getInstructionStr(Lng32 index) 
  { return convInstrInfo[index].instrStr;}
  static const ConvInstruction getInstruction(Lng32 index) 
  { return convInstrInfo[index].instruction;}

  static bool  sv_instrOffsetIndexPopulated;
  static short sv_MaxOpTypeValue;
  static int   *sv_convIndexSparse;
  static void  populateInstrOffsetIndex();
  static int   getInstrOffset(short pv_op1);

  Lng32 findIndexIntoInstrArray(ConvInstruction ci);

  NA_EIDPROC NABoolean treatAllSpacesAsZero()
    { return ((flags_ & TREAT_ALL_SPACES_AS_ZERO) != 0); };

  NA_EIDPROC void setTreatAllSpacesAsZero(NABoolean v)
    { (v) ? flags_ |= TREAT_ALL_SPACES_AS_ZERO : flags_ &= ~TREAT_ALL_SPACES_AS_ZERO; }

  NA_EIDPROC NABoolean allowSignInInterval()
    { return ((flags_ & ALLOW_SIGN_IN_INTERVAL) != 0); };

  NA_EIDPROC void setAllowSignInInterval(NABoolean v)
    { (v) ? flags_ |= ALLOW_SIGN_IN_INTERVAL : flags_ &= ~ALLOW_SIGN_IN_INTERVAL; }

  NA_EIDPROC NABoolean noDatetimeValidation()
    { return ((flags_ & NO_DATETIME_VALIDATION) != 0); };

  NA_EIDPROC void setNoDatetimeValidation(NABoolean v)
    { (v) ? flags_ |= NO_DATETIME_VALIDATION : flags_ &= ~NO_DATETIME_VALIDATION; }

  NABoolean srcIsVarcharPtr()   { return (flags_ & SRC_IS_VARCHAR_PTR) != 0; }
  void setSrcIsVarcharPtr(NABoolean v)
  { (v ? flags_ |= SRC_IS_VARCHAR_PTR : flags_ &= ~SRC_IS_VARCHAR_PTR); }
 
  // Fixup
  //
  NA_EIDPROC Long pack(void *);
  NA_EIDPROC ex_expr::exp_return_type 
    pCodeGenerate(Space *space, UInt32 flags);
  NA_EIDPROC ex_expr::exp_return_type fixup(Space * space = 0,
					    CollHeap * exHeap = 0,
					    char * constants_area = 0,
					    char * temps_area = 0,
					    char * persistentArea = 0,
					    short fixupConstsAndTemps = 0,
					    NABoolean spaceCompOnly = FALSE);

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
				  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(1,getClassVersionID());
    ex_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }
  // ---------------------------------------------------------------------

  NA_EIDPROC void setLastVOAoffset( UInt32 v)
  {
    lastVOAoffset_ = v;
  }

  NA_EIDPROC UInt32 getLastVOAoffset()
  {
    return lastVOAoffset_;
  }

  NA_EIDPROC void setLastVcIndicatorLength( Int16 v)
  {
	  lastVcIndicatorLength_ = v;
  }
  NA_EIDPROC void setLastNullIndicatorLength( Int16 v)
  {
    lastNullIndicatorLength_ = v;
  }

  NA_EIDPROC void setComputedLength( UInt32 v)
  {
    computedLength_ = v;
  }
  NA_EIDPROC UInt32 getComputedLength( )
  {
    return computedLength_;
  }
  NA_EIDPROC void setAlignment( Int16 v)
  {
    alignment_ = v;
  }
  NA_EIDPROC Int16 getAlignment()
  {
    return alignment_;
  }
private:
  enum flags_type 
    {
      REVERSE_DATA_ERROR_CONVERSION_FLAG = 0x0001,  // Reverse data error conversion flag
      
      // when converting string to numeric, if input string contains only
      // spaces or is a null string(length of zero), then the result becomes
      // zero(numeric value of 0).
      TREAT_ALL_SPACES_AS_ZERO           = 0x0002,
      ALLOW_SIGN_IN_INTERVAL             = 0x0004,
      NO_DATETIME_VALIDATION             = 0x0008,
       
      // source is a varchar value which is a pointer to the actual data.
      SRC_IS_VARCHAR_PTR                     = 0x0010,
      // when convert into error, suppress error, move null into convert target
      CONV_TO_NULL_WHEN_ERROR                = 0x0020
    };

  char        filler_[2];           // 00-01

  // Flags
  UInt16      flags_;               // 02-03
  UInt32      lastVOAoffset_;        //
  Int16       lastVcIndicatorLength_;  // 08-09
  Int16       lastNullIndicatorLength_;// 10-11
  UInt32      computedLength_;
  Int16       alignment_;

  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char             fillers_[14];          // 04-31
};

inline Int32 ex_conv_clause::isNullInNullOut() const {
  return ((((ex_conv_clause *)this)->getNumOperands() > 2) ? 0 : 1 );
}

// the following function is used by ex_conv_clause::eval. In order to
// allow conversions from outside of an ex_conv_clause, this function
// is not a method of ex_conv_clause
enum ConvDoItFlags
{
  // while doing conversion, the string target will be blankpadded to the left.
  CONV_LEFT_PAD = 0x0001,

  // while converting ascii to interval, the sign('-', '+') is allowed in
  // the source string.
  CONV_ALLOW_SIGN_IN_INTERVAL = 0x0002,

  // allow invalid code values in the target (e.g, converting from Unicode to ascii)
  // If this bit is set, replace the invalid value with a replacement character.
  // By default (bit not set) an invalid code value results in an error.
  CONV_ALLOW_INVALID_CODE_VALUE = 0x0004,

  // Enable datetime validation when calling convDatetimeDatetime()
  // this is used in FCHECK support
  CONV_ENABLE_DATETIME_VALIDATION = 0x0008,

  // when converting string to numeric, if input string contains only
  // spaces or is a null string(length of zero), then the result becomes
  // zero(numeric value of 0).
  CONV_TREAT_ALL_SPACES_AS_ZERO = 0x0010,

  // invalid date/time/timestamps are allowed.
  // currently used for queries coming in from mariaquest.
  CONV_NO_DATETIME_VALIDATION = 0x0020,

  //Raising an expression error involves the use of convdoit to convert the
  //operands into strings. This flag ensure there is no infinite looping
  //between convdoit and ExRaiseDetailSqlError.
  //Setting the higher bits and allowing lowers ones for convdoit clauses.
  CONV_CONTROL_LOOPING = 0x0040,

  //The following flag is set when performing intermediate conversions so
  //that if the conversion fails, error report would specify it as a failure
  //of an intermediate conversion.
  CONV_INTERMEDIATE_CONVERSION = 0x0080,

  // during CAST from string to timestamp, a date value is extended with
  // zeroed out time part. This flag, if set, disables it.
  // Used when a TIMESTAMP literal is being created which requires the value
  // to exactly match the specified type. 
  CONV_NO_HADOOP_DATE_FIX  = 0x0010
};

// helper function for convDoIt and ex_conv_clause::pCodeGenerate:

// for conversions from REC_BYTE_F_ASCII, REC_BYTE_V_ASCII, or
// REC_BYTE_V_ANSI to one of these three types: Does the conversion
// involve charset conversions, check for partial characters, or check
// for max. number of characters?
inline int requiresNoConvOrVal(Lng32 sourceLen, Lng32 sourcePrecision, Lng32 sourceScale,
                               Lng32 targetLen, Lng32 targetPrecision, Lng32 targetScale,
                               ConvInstruction index)
{
  return (
       // ISO chars are ok - treat UNKNOWN as ISO88591 if the other operand is ISO88591 or unknown
       ((sourceScale == SQLCHARSETCODE_ISO88591 || sourceScale == SQLCHARSETCODE_UNKNOWN) &&
        (targetScale == SQLCHARSETCODE_ISO88591 || targetScale == SQLCHARSETCODE_UNKNOWN))
       
       ||
       
       (// source and target charsets are the same, and...
        targetScale == sourceScale &&

        // ...we do not need to check for partial characters 
        //    (multi-byte chars copied to a shorter target buffer), and...
        (targetLen >= sourceLen ||
         !(CharInfo::isVariableWidthMultiByteCharSet((CharInfo::CharSet) targetScale))) &&

        // ...we do not need to enforce a max. char limit
        //    (target precision is not set or no possibility of exceeding its limit)
        (targetPrecision == 0 ||
         ((targetPrecision >= sourcePrecision && sourcePrecision > 0 ||
           targetPrecision >= sourceLen) && index != CONV_ASCII_F_V)
        )));
}

NA_EIDPROC
SQLEXP_LIB_FUNC
ex_expr::exp_return_type
convDoIt(char * source,
         Lng32 sourceLen,
	 short sourceType,
	 Lng32 sourcePrecision,
	 Lng32 sourceScale,
	 char * target,
	 Lng32 targetLen,
	 short targetType,
	 Lng32 targetPrecision,
	 Lng32 scale,
         char * varCharLen,      // NULL if not a varChar
         Lng32 varCharLenSize,    // 0 if not a varChar
	 CollHeap *heap = 0,
	 ComDiagsArea** diagsArea = 0,
	 ConvInstruction index = CONV_UNKNOWN,
         Lng32 * dataConversionErrorFlag = 0,
	 ULng32 flags = 0);

SQLEXP_LIB_FUNC
ex_expr::exp_return_type
scaleDoIt(char *operand,              // ptr to operand
          Lng32 operandLen,           // len of operand
          Lng32 operandType,          // FS2 type of operand (current representation)
          Lng32 operandCurrScale,     // scale of operand,
                                      // could be charset if converted from char
          Lng32 newScale,             // scale the operand should have
          Lng32 typeOfOldScale,       // type of previous representation of operand,
                                      // to determine what scale really means
          CollHeap * heap);

ex_expr::exp_return_type
convAsciiToInt64(Int64 &target,
		 Lng32 targetScale,
		 char *source,
		 Lng32 sourceLen,
		 CollHeap *heap,
		 ComDiagsArea** diagsArea,
		 ULng32 flags);

ex_expr::exp_return_type 
convAsciiToFloat64(char * target,
		   char *source,
		   Lng32 sourceLen,
		   CollHeap *heap,
		   ComDiagsArea** diagsArea,
		   ULng32 flags);

inline void swapBytes(void *ptr, UInt32 size)
{
   switch (size)
   {
     case 2:
        *(UInt16 *)ptr = bswap_16(*(UInt16 *)ptr);
        break;
     case 4:
        *(UInt32 *)ptr = bswap_32(*(UInt32 *)ptr);
        break;
     case 8:
        *(Int64 *)ptr = bswap_64(*(Int64 *)ptr);
        break;
   }
}

SQLEXP_LIB_FUNC
ex_expr::exp_return_type swapBytes(Attributes *attr,
                                   void *ptr);
/////////////////////////////////////////
// Class ex_function_clause            //
/////////////////////////////////////////
class SQLEXP_LIB_FUNC  ex_function_clause : public ex_clause {

public:
  // Construction
  //
  NA_EIDPROC ex_function_clause(){};
  NA_EIDPROC ex_function_clause(OperatorTypeEnum oper_type,
				short num_operands,
				Attributes ** attr,
				Space * space);


  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const { return 1; };
  NA_EIDPROC Int32 isNullRelevant() const { return 1; };

  // Execution
  //
  NA_EIDPROC Int32 isEvalRelevant() const { return 1; };

  // Fixup
  //
  NA_EIDPROC Long pack(void *);
  NA_EIDPROC ex_expr::exp_return_type 
    pCodeGenerate(Space *space, UInt32 flags);

  NA_EIDPROC NABoolean derivedFunction()
    { return ((flags_ & DERIVED_FUNCTION) != 0); };

  NA_EIDPROC void setDerivedFunction(NABoolean v)
    { (v) ? flags_ |= DERIVED_FUNCTION: flags_ &= ~DERIVED_FUNCTION; }

  NA_EIDPROC NABoolean caseInsensitiveOperation()
    { return ((flags_ & CI_OPERATION) != 0); };

  NA_EIDPROC void setCaseInsensitiveOperation(NABoolean v)
    { (v) ? flags_ |= CI_OPERATION: flags_ &= ~CI_OPERATION; }


  NA_EIDPROC OperatorTypeEnum origFunctionOperType()
                       { return (OperatorTypeEnum)origFunctionOperType_; }
  void setOrigFunctionOperType(OperatorTypeEnum type)
                                  { origFunctionOperType_ = (Int16)type; }


  // Display
  //
  NA_EIDPROC virtual void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(1,getClassVersionID());
    ex_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }
  // ---------------------------------------------------------------------

private:
  // there are times when a function is represented in terms of other
  // functions (See optimizer/BindItemExpr.cpp, class ZZZBinderFunction).
  // The next two fields are used to report errors for these cases.
  // The flags_, if sets to DERIVED_FUNCTION, indicates that this is a function
  // that was used to represent another function. origFunctionOperType_
  // contains the oper type for the original function. This field is valid
  // only if the DERIVED_FUNCTION bit is set in the flags_ field.
  enum
  {
    DERIVED_FUNCTION = 0x00000001,

    // if the function need to do caseinsnsitive operation. Used
    // by REPLACE string function.
    CI_OPERATION = 0x00000002
  };

  Int32 flags_;      // 00-03
  Int16 /*OperatorTypeEnum*/ origFunctionOperType_; // 04-05
  
  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char                       fillers_[10];           // 06-15
};

/////////////////////////////////////////
// Class ex_inout_clause
/////////////////////////////////////////
class SQLEXP_LIB_FUNC  ex_inout_clause : public ex_clause {
public:
  // Consruction
  //
  NA_EIDPROC ex_inout_clause() { flags_ = 0; };
  NA_EIDPROC ex_inout_clause(OperatorTypeEnum oper_type, Attributes ** attr,
			     Space * space);


  // Accessors
  //
  NA_EIDPROC inline char * getName(){ return name; };
  NA_EIDPROC inline void setName(char * name_){ name = name_; };

  NA_EIDPROC inline char * getHeading(){ return heading_; };
  NA_EIDPROC inline void setHeading(char * heading){ heading_ = heading; };

  NA_EIDPROC inline char * getTableName(){ return table_name_; };
  NA_EIDPROC inline void setTableName(char * tn){ table_name_ = tn; };

  NA_EIDPROC inline char * getSchemaName(){ return schema_name_; };
  NA_EIDPROC inline void setSchemaName(char * sn){ schema_name_ = sn; };

  NA_EIDPROC inline char * getCatalogName(){ return catalog_name_; };
  NA_EIDPROC inline void setCatalogName(char * cn){ catalog_name_ = cn; };

  //  NA_EIDPROC inline ex_conv_clause* &getConvClause(){ return convHVClause_; };

  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const { return 0; };
  NA_EIDPROC Int32 isNullRelevant() const { return 0; };

  // Execution
  //
  NA_EIDPROC Int32 isEvalRelevant() const { return 0; };
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0);  

  // Fixup
  //
  NA_EIDPROC Long pack(void *);
  NA_EIDPROC Lng32 unpack(void *, void * reallocator);
  NA_EIDPROC ex_expr::exp_return_type 
    pCodeGenerate(Space *space, UInt32 flags);

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(1,getClassVersionID());
    ex_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }
  // ---------------------------------------------------------------------

  short getParamMode() { return paramMode_; }
  
  short getParamIdx() { return paramIdx_; }

  short getOrdPos() { return ordPos_; }

  void setParamMode (short paramMode) { paramMode_ = paramMode; }
  
  void setParamIdx(short paramIdx) { paramIdx_ = paramIdx; }

  void setOrdPos(short ordPos) { ordPos_ = ordPos; }

  NABoolean excludeFromBulkMove()
  {return (flags_ & EXCLUDE_FROM_BULK_MOVE) != 0;}
  void setExcludeFromBulkMove(NABoolean v)
  { (v ? flags_ |= EXCLUDE_FROM_BULK_MOVE : v &= ~EXCLUDE_FROM_BULK_MOVE);}

private:
  enum
  {
    // if set, this clause is not part of bulk move at runtime.
    // Set at runtime and used for rowwise rowset input.
    EXCLUDE_FROM_BULK_MOVE = 0x0001
  };

  NABasicPtr /* char* */ name;             // 00-07
  NABasicPtr /* char* */ heading_;         // 08-15
  NABasicPtr /* char */ table_name_;       // 16-23
  NABasicPtr /* char */ schema_name_;      // 24-31
  NABasicPtr /* char */ catalog_name_;     // 32-39

  UInt16  flags_;                          // 40-41
  char    filler_1[6];                     // 42-47


  //
  // UDR parameter info
  //
  short paramMode_;                        // 48-49
  short paramIdx_;                         // 50-51
  short ordPos_;                           // 52-53
  short udrFiller_;                        // 54-55

  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char                       fillers_[16];           // 56-71
  
};

/////////////////////////////////////////
// Class noop_clause                   //
/////////////////////////////////////////
class SQLEXP_LIB_FUNC  ex_noop_clause : public ex_clause {

public:
  // Construction
  //
  NA_EIDPROC ex_noop_clause();


  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const { return 0; };
  NA_EIDPROC Int32 isNullRelevant() const { return 0; };

  // Execution
  //
  NA_EIDPROC Int32 isEvalRelevant() const { return 0; };
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0);  

  // Fixup
  //
  NA_EIDPROC Long pack(void *);
  NA_EIDPROC ex_expr::exp_return_type 
    pCodeGenerate(Space *space, UInt32 flags);

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(1,getClassVersionID());
    ex_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }
  // ---------------------------------------------------------------------

private:   

  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char                       fillers_[8];           // 00-07
 
};


/////////////////////////////////////////
// Class un_logic_clause               //
/////////////////////////////////////////
class SQLEXP_LIB_FUNC  ex_unlogic_clause : public ex_clause {

public:
  // Construction
  //
  NA_EIDPROC ex_unlogic_clause(){};
  NA_EIDPROC ex_unlogic_clause(OperatorTypeEnum oper_type, 
			       Attributes ** attr, Space * space);


  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const { return 0; };
  NA_EIDPROC Int32 isNullRelevant() const { return 0; };

  // Execution
  //
  NA_EIDPROC Int32 isEvalRelevant() const { return 1; };
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0);  

  // Fixup
  //
  NA_EIDPROC Long pack(void *);
  NA_EIDPROC ex_expr::exp_return_type 
    pCodeGenerate(Space *space, UInt32 flags);

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(1,getClassVersionID());
    ex_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }

private:

  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char                       fillers_[8];           // 00-07

  // ---------------------------------------------------------------------
};


class SQLEXP_LIB_FUNC  ExRegexpClauseBase : public ex_clause {

public:
  // Construction
  //
  NA_EIDPROC ExRegexpClauseBase() 
  {
    setCollation(CharInfo::DefaultCollation);
  }
  NA_EIDPROC ExRegexpClauseBase(OperatorTypeEnum oper_type,
			    short num_operands,
			    Attributes ** attr,
			    Space * space) :
		ex_clause(ex_clause::LIKE_TYPE, oper_type,
                          num_operands, attr, space
                         ) 
  {
    setCollation(CharInfo::DefaultCollation);
  }


  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const { return 0; };
  NA_EIDPROC Int32 isNullRelevant() const { return 1; };
  NA_EIDPROC ex_expr::exp_return_type processNulls(char *op_data[],
  						   CollHeap * = 0,
						   ComDiagsArea ** = 0);

  // Execution
  //
  NA_EIDPROC Int32 isEvalRelevant() const { return 1; };
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0) = 0;

  // Fixup
  //
  NA_EIDPROC Long pack (void *) = 0;
  
  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea)
    {};


  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(1,getClassVersionID());
    ex_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }

  NA_EIDPROC inline char* getPatternStr()
  {
    return patternStr_;
  }

  NA_EIDPROC inline void setPatternStr(char* pat)
  {
    patternStr_ = pat;
  }

  // Flags used in pcode implementation of like clauses
  enum
  {
    LIKE_HEAD = 0x01,  // Check for pattern at beginning of string only
    LIKE_TAIL = 0x02,  // Check for pattern at end of string only
    END       = 0xFF   // Last possible flag for use in pcode implementation
  };

  // ---------------------------------------------------------------------
protected:
  
  NA_EIDPROC inline CharInfo::Collation getCollation()
  {
    return (CharInfo::Collation) collation_;
  }

  NA_EIDPROC inline void setCollation(CharInfo::Collation v)
  {
    collation_ = (Int16) v;
  }

private:
union {
  LikePattern     *pattern_;          // 00-07
  char            *patternStr_;
};
#ifndef NA_64BIT
  char             fillerPattern_[4]; // 04-07
#endif

  Int16 collation_; //08-09

  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char                       fillers_[14];           // 10-23

};


// Added for unicode like function
class SQLEXP_LIB_FUNC  ExRegexpClauseChar : public ExRegexpClauseBase {

public:
  // Construction
  //
  NA_EIDPROC ExRegexpClauseChar() {};
  NA_EIDPROC ExRegexpClauseChar(OperatorTypeEnum oper_type, 
			    short num_operands,
			    Attributes ** attr,
			    Space * space);


  // Execution
  //
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0);

  // Fixup
  //
  NA_EIDPROC Long pack (void *);

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(2,getClassVersionID());
    ExRegexpClauseBase::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }
  // ---------------------------------------------------------------------

private:

  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char                       fillers_[8];           // 00-07

};
//////////////////////////////////
// Class like_clause            //
//////////////////////////////////

class SQLEXP_LIB_FUNC  ex_like_clause_base : public ex_clause {

public:
  // Construction
  //
  NA_EIDPROC ex_like_clause_base() 
  {
    setCollation(CharInfo::DefaultCollation);
  }
  NA_EIDPROC ex_like_clause_base(OperatorTypeEnum oper_type,
			    short num_operands,
			    Attributes ** attr,
			    Space * space) :
		ex_clause(ex_clause::LIKE_TYPE, oper_type,
                          num_operands, attr, space
                         ) 
  {
    setCollation(CharInfo::DefaultCollation);
  }


  // Null Semantics
  //
  NA_EIDPROC Int32 isNullInNullOut() const { return 0; };
  NA_EIDPROC Int32 isNullRelevant() const { return 1; };
  NA_EIDPROC ex_expr::exp_return_type processNulls(char *op_data[],
  						   CollHeap * = 0,
						   ComDiagsArea ** = 0);

  // Execution
  //
  NA_EIDPROC Int32 isEvalRelevant() const { return 1; };
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0) = 0;

  // Fixup
  //
  NA_EIDPROC Long pack (void *) = 0;
  NA_EIDPROC ex_expr::exp_return_type pCodeGenerate(Space *space, UInt32 flags);

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea)
    {};


  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(1,getClassVersionID());
    ex_clause::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }

  NA_EIDPROC inline char* getPatternStr()
  {
    return patternStr_;
  }

  NA_EIDPROC inline void setPatternStr(char* pat)
  {
    patternStr_ = pat;
  }

  // Flags used in pcode implementation of like clauses
  enum
  {
    LIKE_HEAD = 0x01,  // Check for pattern at beginning of string only
    LIKE_TAIL = 0x02,  // Check for pattern at end of string only
    END       = 0xFF   // Last possible flag for use in pcode implementation
  };

  // ---------------------------------------------------------------------
protected:
  
  NA_EIDPROC inline CharInfo::Collation getCollation()
  {
    return (CharInfo::Collation) collation_;
  }

  NA_EIDPROC inline void setCollation(CharInfo::Collation v)
  {
    collation_ = (Int16) v;
  }

private:
union {
  LikePattern     *pattern_;          // 00-07
  char            *patternStr_;
};
#ifndef NA_64BIT
  char             fillerPattern_[4]; // 04-07
#endif

  Int16 collation_; //08-09

  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char                       fillers_[14];           // 10-23

};

// Added for unicode like function
class SQLEXP_LIB_FUNC  ex_like_clause_char : public ex_like_clause_base {

public:
  // Construction
  //
  NA_EIDPROC ex_like_clause_char() {};
  NA_EIDPROC ex_like_clause_char(OperatorTypeEnum oper_type, 
			    short num_operands,
			    Attributes ** attr,
			    Space * space);


  // Execution
  //
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0);

  // Fixup
  //
  NA_EIDPROC Long pack (void *);

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
					  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  }

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(2,getClassVersionID());
    ex_like_clause_base::populateImageVersionIDArray();
  }

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); }
  // ---------------------------------------------------------------------

private:

  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char                       fillers_[8];           // 00-07

};

class SQLEXP_LIB_FUNC  ex_like_clause_doublebyte: public ex_like_clause_base {

public:
  // Construction
  //
  NA_EIDPROC ex_like_clause_doublebyte() {};
  NA_EIDPROC ex_like_clause_doublebyte(OperatorTypeEnum oper_type, 
			    short num_operands,
			    Attributes ** attr,
			    Space * space);


  // Execution
  //
  NA_EIDPROC ex_expr::exp_return_type eval(char *op_data[],
					   CollHeap * = 0,
					   ComDiagsArea ** = 0);

  // Fixup
  //
  NA_EIDPROC Long pack (void *);

  // Display
  //
  NA_EIDPROC void displayContents(Space * space, const char * displayStr, 
				  Int32 clauseNum, char * constsArea);

  // ---------------------------------------------------------------------
  // Redefinition of methods inherited from NAVersionedObject.
  // ---------------------------------------------------------------------
  NA_EIDPROC virtual unsigned char getClassVersionID()
  {
    return 1;
  };

  NA_EIDPROC virtual void populateImageVersionIDArray()
  {
    setImageVersionID(2,getClassVersionID());
    ex_like_clause_base::populateImageVersionIDArray();
  };

  NA_EIDPROC virtual short getClassSize() { return (short)sizeof(*this); };
  // ---------------------------------------------------------------------

private:
  // ---------------------------------------------------------------------
  // Fillers for potential future extensions without changing class size.
  // When a new member is added, size of this filler should be reduced so
  // that the size of the object remains the same (and is modulo 8).
  // ---------------------------------------------------------------------
  char                       fillers_[8];           // 00-07

};

#pragma warning ( default : 4251 )

#endif