/**********************************************************************
// @@@ 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:         ComTdbTranspose.cpp
* Description:  Methods for the tdb of a TRANSPOSE operation
*
* Created:      5/6/98
* Language:     C++
*
*
*
*
****************************************************************************
*/

#include "ComTdbTranspose.h"
#include "ComTdbCommon.h"

//////////////////////////////////////////////////////////////////////////////
//
//  TDB procedures
//
//////////////////////////////////////////////////////////////////////////////

// Default Constructor
// Used when unpacking the Transpose TDB to get a pointer
// to the Virtual Method Table. Called by ComTdb::fixupVTblPtr().
//
ComTdbTranspose::ComTdbTranspose() :
  ComTdb(ComTdb::ex_TRANSPOSE, eye_TRANSPOSE),
  transTuppIndex_(0)
{
}

// Construct a copy of the given Transpose Tdb.
// (This constructor does not seem to be used)
//
ComTdbTranspose::ComTdbTranspose(const ComTdbTranspose *transTdb)
  : ComTdb(ComTdb::ex_TRANSPOSE,
	   eye_TRANSPOSE,
	   transTdb->getEstRowsUsed(),
           transTdb->criDescDown_,
	   transTdb->criDescUp_,
           transTdb->queueSizeDown_,
	   transTdb->queueSizeUp_,
           transTdb->numBuffers_,
	   transTdb->bufferSize_),
    childTdb_(transTdb->childTdb_),
    transColExprs_(transTdb->transColExprs_),
    numTransExprs_(transTdb->numTransExprs_),
    afterTransPred_(transTdb->afterTransPred_),
    transRowLen_(transTdb->transRowLen_),
    transTuppIndex_(transTdb->transTuppIndex_)
{
}

// Construct a new Transpose TDB.
// This constructor is call by the generator (PhysTranspose::codeGen() in
// GenRelMisc.cpp.) 
//
// Parameters
//
// ComTdb *childTdb
//  IN: The child of this Transpose TDB.
//
// ex_expr **transColExprs
//  IN: A vector of pointers to ex_expr.  There are 'numTransExprs'
//      in the vector.  Each expression represents a transpose expression.
//      Each expression is a move expression which will generate a key
//      value, and multiple values.  One value will be from a transpose
//      expression, the others will generate the NULL value.
//
// int numTransExprs
//  IN: The number of expressions in transColsExprs.
//
// ex_expr *afterTransPred
//  IN: The selection Predicate for the Transpose operator. This expression
//      is applied after the transpose columns have been generated (so this
//      predicate will likely involve these generated values, other wise it
//      could have been pushed to the child of this node.
//
// long transRowLen
//  IN: The length of the tuple which will hold the generated values.  This
//      tuple will be allocated by the transpose node.
//
// const unsigned short transTuppIndex
//  IN: The index of the transpose tuple in the ATP.
//
// ex_cri_desc *criDescDown
//  IN: the Cri Descriptor given to this node by its parent.
//
// ex_cri_desc *criDescUp
//  IN: the Cri Descriptor return to the parent node.
//
// queue_index fromParent
//  IN: Recommended queue size for the down queue used to communicate
//      with the parent.
//
// queue_index toParent
//  IN: Recommended queue size for the up queue used to communicate
//      with the parent.
//
// Cardinality estimatedRowCount
//  IN: compiler estimate on number of returned rows
//
// long numBuffers
//  IN: Recommended number of buffers to allocate.
//
// unsigned long bufferSize
//  IN: Recommended size for pool buffers.
//
ComTdbTranspose::ComTdbTranspose(ComTdb *childTdb,
				 ex_expr **transColExprs,
				 Int32 numTransExprs,
				 ex_expr *afterTransPred,
				 Lng32 transRowLen,
				 const unsigned short transTuppIndex,
				 ex_cri_desc *criDescDown,
				 ex_cri_desc *criDescUp,
				 queue_index fromParent,
				 queue_index toParent,
				 Cardinality estimatedRowCount,
				 Lng32 numBuffers,
				 ULng32 bufferSize,
			         Space *space) :
  ComTdb(ComTdb::ex_TRANSPOSE,
	 eye_TRANSPOSE,
	 estimatedRowCount,
         criDescDown,
	 criDescUp,
         fromParent,
	 toParent,
         numBuffers,
	 bufferSize),
  childTdb_(childTdb),
  numTransExprs_(numTransExprs),
  afterTransPred_(afterTransPred),
  transRowLen_(transRowLen),
  transTuppIndex_(transTuppIndex),
  transColExprs_(space,(void **)transColExprs,numTransExprs)
{
  // Reallocate the array of pointers (which are 64-bit), and assign the
  // pointer values.
  //

  /*
  if (numTransExprs > 0)
  {
    transColExprs_ = (ExExprPtr *) 
      space->allocateAlignedSpace(numTransExprs * sizeof(ExExprPtr));
    for(int i=0; i < numTransExprs; i++) transColExprs_[i] = transColExprs[i];
  }
  */
}

// ComTdbTranspose::Display() -----------------------------------------
// (Don't know why this is here.  It does not seem to be virtual and
// on class seems to do anything for this method.)
//
void
ComTdbTranspose::display() const 
{
  // Do nothing for now.
  //
}

// ComTdbTranspose::pack() ---------------------------------------------
// Pack the transpose TDB for transmission from the compiler to the
// executor, or from an ESP to DP2, etc.  This method needs to convert
// all pointers to offsets, so that the memory containing this TDB fragment,
// can be relocated and 'unpacked' at a new base address.
//
// Parameters
//
// void *space
//  IN - The space object which was used to allocate this TDB. Used to
//       compute offsets all pointers.  It is an error if any pointer
//       that can be reached from this TDB points to memory outside 
//       this space object.
//
Long
ComTdbTranspose::pack(void * space)
{
  // Pack the child TDB, (this calls the pack() method on the child.
  //
  childTdb_.pack(space);
  transColExprs_.pack(space,numTransExprs_);
  afterTransPred_.pack(space);

  // Return the packed pointer to 'this', so that my parent can store the
  // packed version of my address.
  //
  return ComTdb::pack(space);
}

// ComTdbTranspose::unpack() ---------------------------------------------
// Unpack the transpose TDB after transmission from the compiler to the
// executor, or from an ESP to DP2, etc.  This method needs to convert
// all offsets to pointers, so that all pointers now reflected the new
// location of the TDB fragment.
//
// Parameters
//
// long base
//  IN - The base address of the TDB fragment.  Pointers are calculated
//       by adding the offset to the base address (more or less).
//
Lng32
ComTdbTranspose::unpack(void * base, void * reallocator)
{
  if(childTdb_.unpack(base, reallocator)) return -1;
  if(afterTransPred_.unpack(base, reallocator)) return -1;
  if(transColExprs_.unpack(base,numTransExprs_,reallocator)) return -1;
  return ComTdb::unpack(base, reallocator);
}