@@ -266,6 +266,12 @@ static const QueryString getComponentPrivileges[] =
   {" ; "}
 };
 
+static const QueryString getCatalogsQuery[] =
+{
+  {" select * from (values ('TRAFODION'), ('HIVE')) "},
+  {" order by 1 desc "},
+  {" ; "}
+};
 
 static const QueryString getTrafTablesInSchemaQuery[] =
 {
/**********************************************************************
// @@@ 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:         ExExeUtilGet.cpp
 * Description:
 *
 *
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */

#include "ComCextdecs.h"
#include  "cli_stdh.h"
#include  "ex_stdh.h"
#include  "sql_id.h"
#include  "ex_transaction.h"
#include  "ComTdb.h"
#include  "ex_tcb.h"
#include  "ComSqlId.h"
#include  "ComMisc.h"
#include  "ComUser.h"

#include  "ExExeUtil.h"
#include  "ex_exe_stmt_globals.h"
#include  "exp_expr.h"
#include  "exp_clause_derived.h"
#include  "ExpLOB.h"
#include  "ComRtUtils.h"
#include  "CmpCommon.h"
#include  "CmpContext.h"

#include  "sqlcmd.h"
#include  "SqlciEnv.h"

#include  "GetErrorMessage.h"
#include  "ErrorMessage.h"
#include  "HBaseClient_JNI.h"

#include "CmpDDLCatErrorCodes.h"
#include "PrivMgrCommands.h"
#include "PrivMgrComponentPrivileges.h"

#include "ExpHbaseInterface.h"
#include "sql_buffer_size.h"
#include "hdfs.h"

#include "NAType.h"

//******************************************************************************
//                                                                             *
//  These definitions were stolen from CatWellKnownTables.h
//
// Size of CHAR(128) CHARACTER SET UCS2 NOT NULL column is 256 bytes.
#define EX_MD_XXX_NAME_CHAR_LEN "128"
//
// Character type columns in metadata tables are generally case-sensitive
#define ISO_CHAR_ATTR    " CHARACTER SET ISO88591 CASESPECIFIC "
#define UCS2_CHAR_ATTR   " CHARACTER SET UCS2 CASESPECIFIC "
//
// Add explicit collate default to avoid inherit it from table or schema
#define ISO_CHAR_ATTR_2    " CHARACTER SET ISO88591 COLLATE DEFAULT CASESPECIFIC "
#define UCS2_CHAR_ATTR_2   " CHARACTER SET UCS2 COLLATE DEFAULT CASESPECIFIC "
//
// Most - if not all - columns are NNND
#define NNND_ATTR  " NOT NULL NOT DROPPABLE "
//                                                                             *
//******************************************************************************

///////////////////////////////////////////////////////////////////
ex_tcb * ExExeUtilGetMetadataInfoTdb::build(ex_globals * glob)
{
  ExExeUtilGetMetadataInfoTcb * exe_util_tcb;

  if ((groupBy() || orderBy()) ||
      (queryType() == ComTdbExeUtilGetMetadataInfo::OBJECTS_ON_TABLE_) ||
      (queryType() == ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_SCHEMA_))
    exe_util_tcb =
      new(glob->getSpace()) ExExeUtilGetMetadataInfoComplexTcb(*this, glob);
  else if (getVersion())
    exe_util_tcb =
      new(glob->getSpace()) ExExeUtilGetMetadataInfoVersionTcb(*this, glob);
  else if (queryType() == ComTdbExeUtilGetMetadataInfo::HBASE_OBJECTS_)
    exe_util_tcb =
      new(glob->getSpace()) ExExeUtilGetHbaseObjectsTcb(*this, glob);
  else
    exe_util_tcb =
      new(glob->getSpace()) ExExeUtilGetMetadataInfoTcb(*this, glob);

  exe_util_tcb->registerSubtasks();

  return (exe_util_tcb);
}

////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilGetMetadataInfoTcb
///////////////////////////////////////////////////////////////
ExExeUtilGetMetadataInfoTcb::ExExeUtilGetMetadataInfoTcb(
     const ComTdbExeUtilGetMetadataInfo & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilTcb( exe_util_tdb, NULL, glob)
{
  // Allocate the private state in each entry of the down queue
  qparent_.down->allocatePstate(this);

  step_ = INITIAL_;
  vStep_ = VIEWS_INITIAL_;

  // allocate space to hold the metadata query that will be used to retrieve
  // metadata info. 10K is big enough for it.
  queryBuf_ = new(glob->getDefaultHeap()) char[10000];

  // buffer where output will be formatted
  outputBuf_ = new(glob->getDefaultHeap()) char[4096];

  headingBuf_ = new(glob->getDefaultHeap()) char[1000];

  for (Int32 i = 0; i < NUM_MAX_PARAMS_; i++)
    {
      param_[i] = NULL;
    }

  patternStr_ = new(glob->getDefaultHeap()) char[1000];

  numOutputEntries_ = 0;
}

ExExeUtilGetMetadataInfoTcb::~ExExeUtilGetMetadataInfoTcb()
{
  NADELETEBASIC(queryBuf_, getGlobals()->getDefaultHeap());
  NADELETEBASIC(outputBuf_, getGlobals()->getDefaultHeap());
  NADELETEBASIC(headingBuf_, getGlobals()->getDefaultHeap());
  NADELETEBASIC(patternStr_, getGlobals()->getDefaultHeap());
}


static const QueryString getUsersForRoleQuery[] =
{
  {" select translate(rtrim(RU.grantee_name) using ucs2toutf8) "},
  {"   from %s.\"%s\".%s RU "},
  {" where (RU.grantor_ID != -2) and "},
  {"       (RU.role_name = '%s') %s "},
  {" order by 1"},
  {" ; "}
};


static const QueryString getRolesForUserQuery[] =
{
  {" select translate(rtrim(RU.role_name) using ucs2toutf8) "},
  {"   from %s.\"%s\".%s RU "},
  {" where (RU.grantor_ID != -2) and "},
  {"       (RU.grantee_name='%s') %s "},
  {" union select * from (values ('PUBLIC')) "},
  {" order by 1 "},
  {" ; "}
};

static const QueryString getPrivsForAuthsQuery[] = 
{
  {" select translate(rtrim(object_name) using ucs2toutf8), "},
  {"    case when bitextract(privileges_bitmap,63,1) = 1 then 'S' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,62,1) = 1 then 'I' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,61,1) = 1 then 'D' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,60,1) = 1 then 'U' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,59,1) = 1 then 'G' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,58,1) = 1 then 'R' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,57,1) = 1 then 'E' "},
  {"      else '-' end as privs "},
  {" from %s.\"%s\".%s "},
  {" where grantee_id %s "},
  {" union "},
  {"  (select translate(rtrim(object_name) using ucs2toutf8) || ' <Column> ' || "},
  {"          translate(rtrim(column_name) using ucs2toutf8), "},
  {"    case when bitextract(privileges_bitmap,63,1) = 1 then 'S' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,62,1) = 1 then 'I' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,61,1) = 1 then 'D' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,60,1) = 1 then 'U' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,59,1) = 1 then 'G' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,58,1) = 1 then 'R' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,57,1) = 1 then 'E' "},
  {"      else '-' end as privs "},
  {"   from %s.\"%s\".%s p, %s.\"%s\".%s c "},
  {"   where p.object_uid = c.object_uid "},
  {"     and p.column_number = c.column_number "},
  {"     and grantee_id %s )"},
  {" union "},
  {"  (select translate(rtrim(schema_name) using ucs2toutf8), "},
  {"    case when bitextract(privileges_bitmap,63,1) = 1 then 'S' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,62,1) = 1 then 'I' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,61,1) = 1 then 'D' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,60,1) = 1 then 'U' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,59,1) = 1 then 'G' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,58,1) = 1 then 'R' "},
  {"      else '-' end || "},
  {"     case when bitextract(privileges_bitmap,57,1) = 1 then 'E' "},
  {"      else '-' end as privs "},
  {"   from %s.\"%s\".%s "},
  {"   where grantee_id %s )"},
  {" order by 1 "},
  {" ; "}
};

static const QueryString getComponents[] =
{
  {" select distinct translate(rtrim(component_name) using ucs2toutf8)  "},
  {"   from %s.\"%s\".%s c, %s.\"%s\".%s p "},
  {"   where c.component_uid = p.component_uid %s "},
  {" order by 1 "},
  {" ; "}
};

static const QueryString getComponentPrivileges[] = 
{
  {" select distinct translate(rtrim(operation_name) using ucs2toutf8) "},
  {" from %s.\"%s\".%s c, %s.\"%s\".%s o, "},
  {"      %s.\"%s\".%s p "},
  {" where (c.component_uid=o.component_uid) "},
  {"   and (o.component_uid=p.component_uid) "},
  {"   and (o.operation_code=p.operation_code) "},
  {"   and (c.component_name='%s') %s "},
  {" order by 1 "},
  {" ; "}
};


static const QueryString getTrafTablesInSchemaQuery[] =
{
  {" select %sobject_name%s  from "},
  {"   %s.\"%s\".%s "},
  {"  where catalog_name = '%s' and "},
  {"        schema_name = '%s'  and "},
  {"        object_type = 'BT'  "},
  {"  order by 1 "},
  {"  ; "}
};

static const QueryString getTrafIndexesInSchemaQuery[] =
{
  {" select object_name  from "},
  {"   %s.\"%s\".%s "},
  {"  where catalog_name = '%s' and "},
  {"        schema_name = '%s'  and "},
  {"        object_type = 'IX'  "},
  {"  order by 1 "},
  {"  ; "}
};

static const QueryString getTrafIndexesOnTableQuery[] =
{
  {" select %sO2.object_name%s from "},
  {"   %s.\"%s\".%s I, "},
  {"   %s.\"%s\".%s O, "},
  {"   %s.\"%s\".%s O2 "},
  {"  where O.catalog_name = '%s' "},
  {"    and O.schema_name = '%s' "},
  {"    and O.object_name = '%s' "},
  {"    and I.base_table_uid = O.object_uid "},
  {"    and I.index_uid = O2.object_uid "},
  {" order by 1 "},
  {" ; "}
};

static const QueryString getTrafProceduresInSchemaQuery[] =
{
  {" select object_name  from "},
  {"   %s.\"%s\".%s T, %s.\"%s\".%s R "},
  {"  where T.catalog_name = '%s' and "},
  {"        T.schema_name = '%s'  and "},
  {"        T.object_type = 'UR'  and "},
  {"        T.object_uid = R.udr_uid  and "},
  {"        R.udr_type = 'P ' "},
  {"  order by 1 "},
  {"  ; "}
};

static const QueryString getTrafLibrariesInSchemaQuery[] =
{
  {" select object_name  from "},
  {"   %s.\"%s\".%s T "},
  {"  where T.catalog_name = '%s' and "},
  {"        T.schema_name = '%s'  and "},
  {"        T.object_type = 'LB' "},
  {"  order by 1 "},
  {"  ; "}
};

static const QueryString getTrafFunctionsInSchemaQuery[] =
{
  {" select object_name  from "},
  {"   %s.\"%s\".%s T, %s.\"%s\".%s R "},
  {"  where T.catalog_name = '%s' and "},
  {"        T.schema_name = '%s'  and "},
  {"        T.object_type = 'UR'  and "},
  {"        T.object_uid = R.udr_uid  and "},
  {"        R.udr_type = 'F ' "},
  {"  order by 1 "},
  {"  ; "}
};

static const QueryString getTrafTableFunctionsInSchemaQuery[] =
{
  {" select object_name  from "},
  {"   %s.\"%s\".%s T, %s.\"%s\".%s R "},
  {"  where T.catalog_name = '%s' and "},
  {"        T.schema_name = '%s'  and "},
  {"        T.object_type = 'UR'  and "},
  {"        T.object_uid = R.udr_uid  and "},
  {"        R.udr_type = 'T ' "},
  {"  order by 1 "},
  {"  ; "}
};

static const QueryString getTrafProceduresForLibraryQuery[] =
{
  {" select T.schema_name || '.' || T.object_name  from "},
  {"   %s.\"%s\".%s T, %s.\"%s\".%s R, %s.\"%s\".%s LU "},
  {"where T.object_uid = R.udr_uid  and "},
  {"      T.object_uid = LU.used_udr_uid  and "},
  {"      LU.using_library_uid = (select object_uid from %s.\"%s\".%s T1 "},
  {"      where T1.object_type = 'LB' and T1.catalog_name = '%s' and "},
  {"            T1.schema_name = '%s' and T1.object_name = '%s') and "},
  {"      %s  "}, // fot udr_type: procedure, function, or table_mapping fn.
  {"  order by 1 "},
  {"  ; "}
};

static const QueryString getTrafSequencesInSchemaQuery[] =
{
  {" select object_name  from "},
  {"   %s.\"%s\".%s "},
  {"  where catalog_name = '%s' and "},
  {"        schema_name = '%s'  and "},
  {"        object_type = 'SG' "},
  {"  order by 1 "},
  {"  ; "}
};

static const QueryString getTrafSequencesInCatalogQuery[] =
{
  {" select trim(schema_name) || '.' || object_name  from "},
  {"   %s.\"%s\".%s "},
  {"  where catalog_name = '%s' and "},
  {"        object_type = 'SG' "},
  {"  order by 1 "},
  {"  ; "}
};

static const QueryString getTrafViewsInCatalogQuery[] =
{
  {" select schema_name || '.' || "},
  {" object_name from "},
  {"   %s.\"%s\".%s,  %s.\"%s\".%s "},
  {"  where view_uid = object_uid and "},
  {"            catalog_name = '%s' "},
  {" order by 1 "},
  {"  ; "}
};

static const QueryString getTrafViewsInSchemaQuery[] =
{
  {" select object_name from "},
  {"   %s.\"%s\".%s,  %s.\"%s\".%s "},
  {"  where view_uid = object_uid and "},
  {"             catalog_name = '%s' and "},
  {"             schema_name = '%s' "},
  {" order by 1 "},
  {"  ; "}
};

static const QueryString getTrafObjectsInViewQuery[] =
{
  {" select trim(T.catalog_name) || '.' || trim(T.schema_name) || '.' || trim(T.object_name), "},
  {" trim(T.object_type) "},
  {"   from %s.\"%s\".%s VU,  %s.\"%s\".%s T "},
  {"  where VU.using_view_uid = "},
  {"     (select T2.object_uid from  %s.\"%s\".%s T2 "},
  {"         where T2.catalog_name = '%s' and "},
  {"                   T2.schema_name = '%s' and "},
  {"                   T2.object_name = '%s' ) "},
  {"     and VU.used_object_uid = T.object_uid "},
  {" order by 1 "},
  {"  ; "}
};

static const QueryString getTrafViewsOnObjectQuery[] =
{
  {" select trim(T.schema_name) || '.' || trim(T.object_name) from "},
  {"   %s.\"%s\".%s T "},
  {"   where T.object_uid in "},
  {"   (select using_view_uid from  %s.\"%s\".%s VU "},
  {"    where used_object_uid in  "},
  {"     (select object_uid from  "},
  {"        %s.\"%s\".%s T1 "},
  {"      where T1.catalog_name = '%s' "},
  {"          and T1.schema_name = '%s' "},
  {"          and T1.object_name = '%s' "},
  {"          %s "},
  {"     ) "},
  {"   ) "},
  {" order by 1 "},
  {" ; "}
};

static const QueryString getTrafSchemasInCatalogQuery[] =
{
  {" select schema_name "},
  {"   from %s.\"%s\".%s "},
  {"  where catalog_name = '%s' "},
  {"        and (object_type = 'PS' or object_type = 'SS') "},
  {" order by 1 "},
  {"  ; "}
};

static const QueryString getTrafSchemasForAuthIDQuery[] =
{
  {" select T.schema_name "},
  {"   from %s.\"%s\".%s T, "},
  {"        %s.\"%s\".%s A "},
  {"  where (T.object_type = 'PS' or T.object_type = 'SS') and "},
  {"         A.auth_db_name = '%s' and T.object_owner = A.auth_id  "},
  {" order by 1 "},
  {"  ; "}
};

static const QueryString getTrafUsers[] = 
{
  {" select distinct auth_db_name "},
  {"   from %s.\"%s\".%s "},
  {"  where auth_type = 'U' %s "},
  {" order by 1 "},
  {"  ; "}
};

static const QueryString getTrafRoles[] = 
{
  {" select distinct auth_db_name "},
  {"   from %s.\"%s\".%s "},
  {"  where auth_type = 'R' %s "},
  {" union select * from (values ('PUBLIC')) "},
  {" order by 1 "},
  {"  ; "}
};
Lng32 ExExeUtilGetMetadataInfoTcb::getUsingView(Queue * infoList,
					       NABoolean isShorthandView,
					       char* &viewName, Lng32 &len)
{
  Lng32 cliRC = 0;

  while (1)
    {
      switch (vStep_)
	{
	case VIEWS_INITIAL_:
	  {
	    infoList->position();

	    vStep_ = VIEWS_FETCH_PROLOGUE_;
	  }
	break;

	case VIEWS_FETCH_PROLOGUE_:
	  {
	    if (infoList->atEnd())
	      {
		vStep_ = VIEWS_DONE_;
		break;
	      }

	    OutputInfo * vi = (OutputInfo*)infoList->getCurr();
	    char * ptr = vi->get(0);

	    char * outBuf = new(getGlobals()->getDefaultHeap())
	      char[ComMAX_3_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES+6+1];

	    char * parts[4];
	    Lng32 numParts = 0;
	    LateNameInfo::extractParts(ptr, outBuf, numParts, parts, 
				       ((ptr[0] == '\"') ? FALSE : TRUE));

	    char query[2000];
	    if (isShorthandView)
	      {
		if (numParts == 1)
		  {
		    str_sprintf(query, "get all views on view %s, no header;",
				parts[0]);
		  }
		else if (numParts == 2)
		  {
		    str_sprintf(query, "get all views on view \"%s\".%s.%s, no header;",
				getMItdb().getCat(), parts[0], parts[1]);
		  }
		else if (numParts == 3)
		  {
		    str_sprintf(query, "get all views on view %s.%s.%s, no header;",
				parts[0], parts[1], parts[2]);
		  }
	      }
	    else
	      {
		if (numParts == 1)
		  {
		    str_sprintf(query, "get all mvs on mv %s, no header;",
				parts[0]);
		  }
		else if (numParts == 2)
		  {
		    str_sprintf(query, "get all mvs on mv \"%s\".%s.%s, no header;",
				getMItdb().getCat(), parts[0], parts[1]);
		  }
		else if (numParts == 3)
		  {
		    str_sprintf(query, "get all mvs on mv %s.%s.%s, no header;",
				parts[0], parts[1], parts[2]);
		  }
	      }

	    NADELETEBASIC(outBuf, getGlobals()->getDefaultHeap());

	    cliRC = cliInterface()->fetchRowsPrologue(query);
	    if (cliRC < 0)
	      {
		cliInterface()->retrieveSQLDiagnostics(getDiagsArea());

		vStep_ = VIEWS_ERROR_;
		break;
	      }

	    vStep_ = VIEWS_FETCH_ROW_;
	  }
	break;

	case VIEWS_FETCH_ROW_:
	  {
	    cliRC = cliInterface()->fetch();
	    if (cliRC < 0)
	      {
		cliInterface()->retrieveSQLDiagnostics(getDiagsArea());

		vStep_ = VIEWS_ERROR_;
		break;
	      }

	    if (cliRC == 100)
	      {
		vStep_ = VIEWS_FETCH_EPILOGUE_;
		break;
	      }

	    cliInterface()->getPtrAndLen(1, viewName, len);
	    return 0;
	  }
	break;

	case VIEWS_ERROR_:
	  {
	    vStep_ = VIEWS_INITIAL_;
	    return cliRC;
	  }
	break;

	case VIEWS_FETCH_EPILOGUE_:
	  {
	    cliRC = cliInterface()->fetchRowsEpilogue(0);
	    if (cliRC < 0)
	      {
		cliInterface()->retrieveSQLDiagnostics(getDiagsArea());

		vStep_ = VIEWS_ERROR_;
		break;
	      }

	    infoList->advance();

	    vStep_ = VIEWS_FETCH_PROLOGUE_;
	  }
	break;

	case VIEWS_DONE_:
	  {
	    // all done
	    vStep_ = VIEWS_INITIAL_;
	    return 100;
	  }
	break;

	}
    }
}

Lng32 ExExeUtilGetMetadataInfoTcb::getUsedObjects(Queue * infoList,
						 NABoolean isShorthandView,
						 char* &viewName, Lng32 &len)
{
  Lng32 cliRC = 0;

  while (1)
    {
      switch (vStep_)
	{
	case VIEWS_INITIAL_:
	  {
	    infoList->position();

	    vStep_ = VIEWS_FETCH_PROLOGUE_;
	  }
	break;

	case VIEWS_FETCH_PROLOGUE_:
	  {
	    if (infoList->atEnd())
	      {
		vStep_ = VIEWS_DONE_;
		break;
	      }

	    OutputInfo * vi = (OutputInfo*)infoList->getCurr();
	    char * ptr = vi->get(0);
	    char * objTyp = vi->get(1);

	    if ((objTyp) && (strcmp(objTyp, "BT") == 0))
	      {
		infoList->advance();

		vStep_ = VIEWS_FETCH_PROLOGUE_;
		break;
	      }

	    char * outBuf = new(getGlobals()->getDefaultHeap())
	      char[ComMAX_3_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES+6+1];

	    char * parts[4];
	    Lng32 numParts = 0;
	    LateNameInfo::extractParts(ptr, outBuf, numParts, parts, TRUE);

	    char query[2000];
	    char objectStr[20];

	    if (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::TABLES_IN_VIEW_)
	      strcpy(objectStr, "tables");
	    else if (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::VIEWS_IN_VIEW_)
	      strcpy(objectStr, "views");
	    else if (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_VIEW_)
	      strcpy(objectStr, "objects");
	    else if (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::TABLES_IN_MV_)
	      strcpy(objectStr, "tables");
	    else if (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::MVS_IN_MV_)
	      strcpy(objectStr, "mvs");
	    else if (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_MV_)
	      strcpy(objectStr, "objects");

	    char inStr[10];
	    if (isShorthandView)
	      strcpy(inStr, "view");
	    else
	      strcpy(inStr, "mv");

	    if (numParts == 1)
	      str_sprintf(query, "get all %s in %s %s, no header",
			  objectStr, inStr, parts[0]);
	    else if (numParts == 2)
	      str_sprintf(query, "get all %s in %s %s.%s, no header",
			  objectStr, inStr, parts[0], parts[1]);
	    else if (numParts == 3)
	      str_sprintf(query, "get all %s in %s %s.%s.%s, no header",
			  objectStr, inStr, parts[0], parts[1], parts[2]);

	    if (getMItdb().getPattern())
	      {
		strcat(query, ", match '");
		strcat(query, getMItdb().getPattern());
		strcat(query, "'");
	      }

	    strcat(query, ";");

	    NADELETEBASIC(outBuf, getGlobals()->getDefaultHeap());

	    cliRC = cliInterface()->fetchRowsPrologue(query);
	    if (cliRC < 0)
	      {
		cliInterface()->retrieveSQLDiagnostics(getDiagsArea());

		vStep_ = VIEWS_ERROR_;
		break;
	      }

	    vStep_ = VIEWS_FETCH_ROW_;
	  }
	break;

	case VIEWS_FETCH_ROW_:
	  {
	    cliRC = cliInterface()->fetch();
	    if (cliRC < 0)
	      {
		cliInterface()->retrieveSQLDiagnostics(getDiagsArea());

		vStep_ = VIEWS_ERROR_;
		break;
	      }

	    if (cliRC == 100)
	      {
		vStep_ = VIEWS_FETCH_EPILOGUE_;
		break;
	      }

	    cliInterface()->getPtrAndLen(1, viewName, len);
	    return 0;
	  }
	break;

	case VIEWS_ERROR_:
	  {
	    vStep_ = VIEWS_INITIAL_;
	    return cliRC;
	  }
	break;

	case VIEWS_FETCH_EPILOGUE_:
	  {
	    cliRC = cliInterface()->fetchRowsEpilogue(0);
	    if (cliRC < 0)
	      {
		cliInterface()->retrieveSQLDiagnostics(getDiagsArea());

		vStep_ = VIEWS_ERROR_;
		break;
	      }

	    infoList->advance();

	    vStep_ = VIEWS_FETCH_PROLOGUE_;
	  }
	break;

	case VIEWS_DONE_:
	  {
	    // all done
	    vStep_ = VIEWS_INITIAL_;
	    return 100;
	  }
	break;

	}
    }
}

short ExExeUtilGetMetadataInfoTcb::displayHeading()
{
  if (getMItdb().noHeader())
    {
      return 0;
    }
  // make sure there is enough space to move header
  if ((qparent_.up->getSize() - qparent_.up->getLength()) < 7)
    return 1;	//come back later

  switch (getMItdb().queryType_)
    {
    case ComTdbExeUtilGetMetadataInfo::CATALOGS_:
      {
	str_sprintf(headingBuf_, "Catalogs");
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::SCHEMAS_IN_CATALOG_:
      {
	str_sprintf(headingBuf_, "Schemas in Catalog %s",
		    getMItdb().getCat());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::INVALID_VIEWS_IN_CATALOG_:
      {
	str_sprintf(headingBuf_, "Invalid Views in Catalog %s",
		    getMItdb().getCat());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::TABLES_IN_CATALOG_:
      {
	str_sprintf(headingBuf_, "Tables in Catalog %s",
		    getMItdb().getCat());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::VIEWS_IN_CATALOG_:
      {
	str_sprintf(headingBuf_, "Views in Catalog %s",
		    getMItdb().getCat());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_CATALOG_:
      {
	str_sprintf(headingBuf_, "Objects in Catalog %s",
		    getMItdb().getCat());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::TABLES_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Tables in Schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::INDEXES_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Indexes in Schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::VIEWS_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Views in Schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Objects in Schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::INVALID_VIEWS_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Invalid Views in Schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::LIBRARIES_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Libraries in Schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::MVS_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "MVs in Schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::PROCEDURES_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Procedures in Schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::FUNCTIONS_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Functions in Schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::TABLE_FUNCTIONS_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Table_mapping functions in Schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::SYNONYMS_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Synonyms in Schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::INDEXES_ON_TABLE_:
      {
	str_sprintf(headingBuf_, "Indexes on Table %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::INDEXES_ON_MV_:
      {
	str_sprintf(headingBuf_, "Indexes on MV %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::PRIVILEGES_ON_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Privileges on Schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::PRIVILEGES_ON_TABLE_:
      {
	str_sprintf(headingBuf_, "Privileges on Table %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::PRIVILEGES_ON_MV_:
      {
	str_sprintf(headingBuf_, "Privileges on MV %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::PRIVILEGES_ON_VIEW_:
      {
	str_sprintf(headingBuf_, "Privileges on View %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::SYNONYMS_ON_TABLE_:
      {
	str_sprintf(headingBuf_, "Synonyms on Table %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::VIEWS_ON_TABLE_:
    case ComTdbExeUtilGetMetadataInfo::VIEWS_ON_VIEW_:
      {
	str_sprintf(headingBuf_,
		    (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::VIEWS_ON_TABLE_
		     ? "Views on Table %s.%s" : "Views ON View %s.%s"),
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::MVS_ON_TABLE_:
    case ComTdbExeUtilGetMetadataInfo::MVS_ON_MV_:
      {
	str_sprintf(headingBuf_,
		    (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::MVS_ON_TABLE_
		     ? "MVs on Table %s.%s" : "MVs ON MV %s.%s"),
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::PARTITIONS_FOR_TABLE_:
      {
	str_sprintf(headingBuf_, "Partitions for Table %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;

     case ComTdbExeUtilGetMetadataInfo::IUDLOG_TABLE_ON_TABLE_:
      {
	str_sprintf(headingBuf_, "Iudlog tables  for Table %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;
    case ComTdbExeUtilGetMetadataInfo::RANGELOG_TABLE_ON_TABLE_:
      {
	str_sprintf(headingBuf_, "Rangelog table for Table %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;
     case ComTdbExeUtilGetMetadataInfo::TRIGTEMP_TABLE_ON_TABLE_:
      {
	str_sprintf(headingBuf_, "Trigger temp table for Table %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
      break;
     case ComTdbExeUtilGetMetadataInfo::IUDLOG_TABLE_ON_MV_:
      {
	str_sprintf(headingBuf_, "Iudlog table  for MV %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;
    case ComTdbExeUtilGetMetadataInfo::RANGELOG_TABLE_ON_MV_:
      {
	str_sprintf(headingBuf_, "Rangelog table for MV %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;
     case ComTdbExeUtilGetMetadataInfo::TRIGTEMP_TABLE_ON_MV_:
      {
	str_sprintf(headingBuf_, "Trigger temp table for MV %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;
    case ComTdbExeUtilGetMetadataInfo::PARTITIONS_FOR_INDEX_:
      {
	str_sprintf(headingBuf_, "Partitions for Index %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::OBJECTS_ON_TABLE_:
      {
	str_sprintf(headingBuf_, "Objects on Table %s.%s",
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::IUDLOG_TABLES_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Iud log tables in schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;
    case ComTdbExeUtilGetMetadataInfo::RANGELOG_TABLES_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Range log tables in schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::TRIGTEMP_TABLES_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Trigger temp tables in schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::SEQUENCES_IN_SCHEMA_:
      {
	str_sprintf(headingBuf_, "Sequences in schema %s.%s",
		    getMItdb().getCat(), getMItdb().getSch());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::SEQUENCES_IN_CATALOG_:
      {
	str_sprintf(headingBuf_, "Sequences in catalog %s",
		    getMItdb().getCat());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::TABLES_IN_VIEW_:
    case ComTdbExeUtilGetMetadataInfo::VIEWS_IN_VIEW_:
    case ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_VIEW_:
      {
	str_sprintf(headingBuf_,
		    (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::TABLES_IN_VIEW_ ?
		     "Tables in View %s.%s" :
		     (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::VIEWS_IN_VIEW_ ?
		      "Views in View %s.%s" :
		      "Objects in View %s.%s")),
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::TABLES_IN_MV_:
    case ComTdbExeUtilGetMetadataInfo::MVS_IN_MV_:
    case ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_MV_:
      {
	str_sprintf(headingBuf_,
		    (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::TABLES_IN_MV_ ?
		     "Tables in MV %s.%s" :
		     (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::MVS_IN_MV_ ?
		      "MVs in MV %s.%s" :
		      "Objects in MV %s.%s")),
		    getMItdb().getSch(), getMItdb().getObj());
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::ROLES_:
        str_sprintf(headingBuf_,"Roles");
    break;

    case ComTdbExeUtilGetMetadataInfo::ROLES_FOR_ROLE_:
        str_sprintf(headingBuf_,"Roles granted Role %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::USERS_FOR_ROLE_:
        str_sprintf(headingBuf_,"Users granted Role %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::USERS_:
    case ComTdbExeUtilGetMetadataInfo::CURRENT_USER_:
      {
        str_sprintf(headingBuf_,
                    (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::USERS_
                     ? "Users" : "Current User")
        );
      }
    break;

    case ComTdbExeUtilGetMetadataInfo::CATALOGS_FOR_USER_:
        str_sprintf(headingBuf_,"Catalogs for User %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::INDEXES_FOR_USER_:
        str_sprintf(headingBuf_,"Indexes for User %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::LIBRARIES_FOR_USER_:
        str_sprintf(headingBuf_,"Libraries for User %s", getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::PROCEDURES_FOR_LIBRARY_:
        str_sprintf(headingBuf_,"Procedures for Library %s.%s",getMItdb().getSch(), getMItdb().getObj());
    break;

    case ComTdbExeUtilGetMetadataInfo::FUNCTIONS_FOR_LIBRARY_:
        str_sprintf(headingBuf_,"Functions for Library %s.%s",getMItdb().getSch(), getMItdb().getObj());
    break;

    case ComTdbExeUtilGetMetadataInfo::TABLE_FUNCTIONS_FOR_LIBRARY_:
        str_sprintf(headingBuf_,"Table_mapping Functions for Library %s.%s",getMItdb().getSch(), getMItdb().getObj());
    break;

    case ComTdbExeUtilGetMetadataInfo::MVS_FOR_USER_:
        str_sprintf(headingBuf_,"Materialized Views for User %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::MVGROUPS_FOR_USER_:
        str_sprintf(headingBuf_,"Materialized View Groups for User %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::PRIVILEGES_FOR_USER_:
        str_sprintf(headingBuf_,"Privileges for User %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::PRIVILEGES_FOR_ROLE_:
        str_sprintf(headingBuf_,"Privileges for Role %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::PROCEDURES_FOR_USER_:
        str_sprintf(headingBuf_,"Procedures for User %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::ROLES_FOR_USER_:
        str_sprintf(headingBuf_,"Roles for User %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::SCHEMAS_FOR_USER_:
        str_sprintf(headingBuf_,"Schemas for User %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::SYNONYMS_FOR_USER_:
        str_sprintf(headingBuf_,"Synonyms for User %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::TABLES_FOR_USER_:
        str_sprintf(headingBuf_,"Tables for User %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::TRIGGERS_FOR_USER_:
        str_sprintf(headingBuf_,"Triggers for User %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::VIEWS_FOR_USER_:
        str_sprintf(headingBuf_,"Views for User %s",getMItdb().getParam1());
    break;

    case ComTdbExeUtilGetMetadataInfo::COMPONENTS_:
        str_sprintf(headingBuf_, "Components");
    break;

    case ComTdbExeUtilGetMetadataInfo::COMPONENT_PRIVILEGES_:
       {	 
      	 if (getMItdb().getParam1())
            str_sprintf(headingBuf_, "Privilege information on Component %s for %s",
                        getMItdb().getObj(),getMItdb().getParam1());
         
         else
            str_sprintf(headingBuf_, "Operation information on Component %s",
                        getMItdb().getObj());
         break;
       }

    default:
      str_sprintf(headingBuf_, "Add to ExExeUtilGetMetadataInfoTcb::displayHeading");
      break;
    }

  moveRowToUpQueue(headingBuf_);
  str_pad(outputBuf_, strlen(headingBuf_), '=');
  outputBuf_[strlen(headingBuf_)] = 0;
  moveRowToUpQueue(outputBuf_);

  moveRowToUpQueue(" ");

  return 0;
} // ExExeUtilGetMetadataInfoTcb::displayHeading

// ----------------------------------------------------------------------------
// getAuthID
//
// Reads the "_MD_".auths table to get the auth_id from the passed in authName.
// If relationship not found for any reason, return 0, otherwise return
// the authID.
// ----------------------------------------------------------------------------
Int32 ExExeUtilGetMetadataInfoTcb::getAuthID(
  const char *authName,
  const char *catName,
  const char *schName, 
  const char *objName)
{
  if (strcmp(authName, PUBLIC_AUTH_NAME) == 0)
    return PUBLIC_USER;

  short rc      = 0;
  Lng32 cliRC   = 0;

  sprintf(queryBuf_, "select auth_id from %s.\"%s\".%s where auth_db_name = '%s' ",
          catName, schName, objName, authName);

  if (initializeInfoList(infoList_)) return NA_UserIdDefault;

  numOutputEntries_ = 1;
  cliRC = fetchAllRows(infoList_, queryBuf_, numOutputEntries_, FALSE, rc);
  if (cliRC < 0) 
  {
    cliInterface()->retrieveSQLDiagnostics(getDiagsArea());
    return NA_UserIdDefault;
  }

  infoList_->position();
  OutputInfo * vi = (OutputInfo*)infoList_->getCurr();
  if (vi)
    return *(Lng32*)vi->get(0);
  return NA_UserIdDefault;
}

// ----------------------------------------------------------------------------
// getRoleList
//
// Reads the "_PRIVMGR_MD_".role_usage table to return the list of role IDs
// granted to the user specified in userID.
//
// If none found, or an unexpected error occurs, NULL is returned.
// The function allocates memory for the returned role list, the caller is
// responsible for deleting this memory.
//
// The returned role list includes the roles granted, plus the userID passed
// in, plus the special role PUBLIC.  It is returned in a format that can be
// used in a query "in" clause.
//
// For example:
//   (-1, 33334, 1000004, 1000056)
// ----------------------------------------------------------------------------
char * ExExeUtilGetMetadataInfoTcb::getRoleList(
  const Int32 userID,
  const char *catName,
  const char *schName,
  const char *objName)
{
  short rc      = 0;
  Lng32 cliRC   = 0;

  sprintf(queryBuf_, "select role_id from %s.\"%s\".%s where grantee_id = %d ",
          catName, schName, objName, userID);

  if (initializeInfoList(infoList_)) return NULL;

  numOutputEntries_ = 1;
  cliRC = fetchAllRows(infoList_, queryBuf_, numOutputEntries_, FALSE, rc);
  if (cliRC < 0)
  {
    cliInterface()->retrieveSQLDiagnostics(getDiagsArea());
    return NULL;
  }

  NAString roleList("(-1");
  char buf[30];
  NABoolean isFirst = TRUE;
  infoList_->position();
  while (NOT infoList_->atEnd())
    {
      OutputInfo * vi = (OutputInfo*)infoList_->getCurr();
      if (vi)
      {
        roleList += ", ";
        str_sprintf(buf, "%d", *(Lng32*)vi->get(0));
        roleList += buf;
        isFirst = FALSE;
      }
      infoList_->advance();
    }
  str_sprintf(buf, ", %d)", userID);
  roleList += buf;

  char * list = new (getHeap()) char [roleList.length() + 1];
  strcpy(list, roleList.data());
  list[roleList.length()] = 0;

  return list;
}


// ----------------------------------------------------------------------------
// method:  checkUserPrivs
//
//  return TRUE to add privilege checks to queries
//  return FALSE to return all details independent of privileges
// ----------------------------------------------------------------------------
NABoolean ExExeUtilGetMetadataInfoTcb::checkUserPrivs(
  ContextCli * currContext,
  const ComTdbExeUtilGetMetadataInfo::QueryType queryType)
{
  // if no authorization, everyone sees everything
  if (!CmpCommon::context()->isAuthorizationEnabled())
    return FALSE;

  // Root user sees everything
  if (ComUser::isRootUserID())
    return FALSE;

  // any user granted the DB__ROOTROLE sees everything
  Int32 numRoles;
  Int32 *roleList;
  if (currContext->getRoleList(numRoles, roleList) == SUCCESS)
  {
    char authIDAsChar[sizeof(Int32)+10];
    NAString auths;
    for (Int32 i = 0; i < numRoles; i++)
    {
      if (roleList[i] == ROOT_ROLE_ID)
        return FALSE;
    }
  }

  // any user granted the SHOW component privilege sees everything
  std::string privMDLoc = getMItdb().cat_.getPointer();
  privMDLoc += ".\"";
  privMDLoc += SEABASE_PRIVMGR_SCHEMA;
  privMDLoc += "\"";
  PrivMgrComponentPrivileges componentPrivileges(privMDLoc,getDiagsArea());

  if (componentPrivileges.hasSQLPriv(ComUser::getCurrentUser(),SQLOperation::SHOW,true))
    return FALSE;

  // Check component privilege based on QueryType
  switch (queryType)
  {
    // if user has MANAGE_ROLES, can perform role operations
    case ComTdbExeUtilGetMetadataInfo::ROLES_:
    case ComTdbExeUtilGetMetadataInfo::ROLES_FOR_ROLE_:
    case ComTdbExeUtilGetMetadataInfo::ROLES_FOR_USER_:
    {
      if (componentPrivileges.hasSQLPriv(ComUser::getCurrentUser(),SQLOperation::MANAGE_ROLES, true))
        return FALSE;
      break;
    }

    // if user has MANAGE_USERS, can perform user operations
    case ComTdbExeUtilGetMetadataInfo::USERS_:
    case ComTdbExeUtilGetMetadataInfo::USERS_FOR_ROLE_:
    {
      if (componentPrivileges.hasSQLPriv(ComUser::getCurrentUser(),SQLOperation::MANAGE_USERS,true))
        return FALSE;
      break;
    }

    // if user has MANAGE_COMPONENTS, can perform component operations
    case ComTdbExeUtilGetMetadataInfo::COMPONENTS_:
    case ComTdbExeUtilGetMetadataInfo::COMPONENT_OPERATIONS_:
    case ComTdbExeUtilGetMetadataInfo::COMPONENT_PRIVILEGES_:
    {
      if (componentPrivileges.hasSQLPriv(ComUser::getCurrentUser(),SQLOperation::MANAGE_COMPONENTS,true))
        return FALSE;
      break;
    }

    // if user has MANAGE_LIBRARIES, can perform library operations
    case ComTdbExeUtilGetMetadataInfo::PROCEDURES_FOR_LIBRARY_:
    case ComTdbExeUtilGetMetadataInfo::FUNCTIONS_FOR_LIBRARY_:
    case ComTdbExeUtilGetMetadataInfo::TABLE_FUNCTIONS_FOR_LIBRARY_:
    {
      if (componentPrivileges.hasSQLPriv(ComUser::getCurrentUser(),SQLOperation::MANAGE_LIBRARY,true))
        return FALSE;
      break;
    }

   // if user has DML_SELECT, can perform object operations
   case ComTdbExeUtilGetMetadataInfo::CATALOGS_:
   case ComTdbExeUtilGetMetadataInfo::SCHEMAS_IN_CATALOG_:
   case ComTdbExeUtilGetMetadataInfo::VIEWS_IN_CATALOG_:
   case ComTdbExeUtilGetMetadataInfo::SEQUENCES_IN_CATALOG_:
   case ComTdbExeUtilGetMetadataInfo::TABLES_IN_SCHEMA_:
   case ComTdbExeUtilGetMetadataInfo::INDEXES_IN_SCHEMA_:
   case ComTdbExeUtilGetMetadataInfo::VIEWS_IN_SCHEMA_:
   case ComTdbExeUtilGetMetadataInfo::LIBRARIES_IN_SCHEMA_:
   case ComTdbExeUtilGetMetadataInfo::PROCEDURES_IN_SCHEMA_:
   case ComTdbExeUtilGetMetadataInfo::SEQUENCES_IN_SCHEMA_:
   case ComTdbExeUtilGetMetadataInfo::FUNCTIONS_IN_SCHEMA_:
   case ComTdbExeUtilGetMetadataInfo::TABLE_FUNCTIONS_IN_SCHEMA_:
   case ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_SCHEMA_:
   case ComTdbExeUtilGetMetadataInfo::INDEXES_ON_TABLE_:
   case ComTdbExeUtilGetMetadataInfo::VIEWS_ON_TABLE_:
   case ComTdbExeUtilGetMetadataInfo::VIEWS_ON_VIEW_:
   case ComTdbExeUtilGetMetadataInfo::OBJECTS_ON_TABLE_:
   case ComTdbExeUtilGetMetadataInfo::PARTITIONS_FOR_TABLE_:
   case ComTdbExeUtilGetMetadataInfo::PARTITIONS_FOR_INDEX_:
   case ComTdbExeUtilGetMetadataInfo::TABLES_IN_VIEW_:
   case ComTdbExeUtilGetMetadataInfo::VIEWS_IN_VIEW_:
   case ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_VIEW_:
    {
      if (componentPrivileges.hasSQLPriv(ComUser::getCurrentUser(),SQLOperation::DML_SELECT,true))
        return FALSE;
      break;
    }
   default:
     break;
  }
  return TRUE;
}

//////////////////////////////////////////////////////
// work() for ExExeUtilGetMetadataInfoTcb
//////////////////////////////////////////////////////
short ExExeUtilGetMetadataInfoTcb::work()
{
  short retcode = 0;
  Lng32 cliRC = 0;
  ex_expr::exp_return_type exprRetCode = ex_expr::EXPR_OK;

  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;

  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;

  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getStatement()->getContext();

  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
	    step_ = DISABLE_CQS_;

	    headingReturned_ = FALSE;

	    numOutputEntries_ = 1;

	    objectUid_[0] = 0;
	  }
	break;

	case DISABLE_CQS_:
	  {
	    if (disableCQS())
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

            // assume for now that everything is an HBase object

            // In the future, we may wish to check the TDB to see
            // what kind of object is being queried, and pick the
            // relevant step as a result. One thing that should be
            // kept in mind though is that we want nice semantics
            // when the object doesn't exist. Today, when a catalog
            // does not exist, for example, GET SCHEMAS simply
            // returns nothing. Similarly, when a catalog exists
            // but the schema does not, GET TABLES returns nothing.

	    step_ = SETUP_HBASE_QUERY_;
	  }
	break;

	case SETUP_HBASE_QUERY_:
	  {
	    const QueryString * qs = NULL;
	    Int32 sizeOfqs = 0;
            NAString userQuery;

	    char ausStr[1000];
	    str_sprintf(ausStr, "");
	    char catSchValue[ComMAX_2_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES+50];
	    str_sprintf(catSchValue, "");
	    char endQuote[10];
	    str_sprintf(endQuote, "");

	    if (getMItdb().returnFullyQualNames())
	      {
		str_sprintf(catSchValue, "'\"%s\".\"%s\".\"' || ",
			    getMItdb().getCat(), getMItdb().getSch());

		str_sprintf(endQuote, "|| '\"' ");
	      }

	    char cat[100];
	    char sch[100];
            char pmsch[100];
	    char tab[100];
	    char col[100];
            char indexes[100];
	    char view[100];
	    char view_usage[100];
            char auths[100];
            char role_usage[100];
            char objPrivs[100];
            char schPrivs[100];
            char colPrivs[100];
            char components[100];
            char componentOperations[100];
            char componentPrivileges[100];
            char routine[100];
            char library_usage[100];

	    cliInterface()->getCQDval("SEABASE_CATALOG", cat);

	    //	    strcpy(cat, TRAFODION_SYSCAT_LIT);
	    strcpy(sch, SEABASE_MD_SCHEMA);
	    strcpy(pmsch, SEABASE_PRIVMGR_SCHEMA);
	    strcpy(tab, SEABASE_OBJECTS);
	    strcpy(col, SEABASE_COLUMNS);
	    strcpy(view, SEABASE_VIEWS);
	    strcpy(view_usage, SEABASE_VIEWS_USAGE);
            strcpy(indexes, SEABASE_INDEXES);
            strcpy(auths, SEABASE_AUTHS);
            strcpy(objPrivs, "OBJECT_PRIVILEGES");
            strcpy(colPrivs, "COLUMN_PRIVILEGES");
            strcpy(schPrivs, "SCHEMA_PRIVILEGES");
            strcpy(role_usage, "ROLE_USAGE");
            strcpy(components, "COMPONENTS");
            strcpy(componentOperations, "COMPONENT_OPERATIONS");
            strcpy(componentPrivileges, "COMPONENT_PRIVILEGES");
            strcpy(routine, SEABASE_ROUTINES);
            strcpy(library_usage, SEABASE_LIBRARIES_USAGE);

            // Determine if need to restrict data to user visable data only.
            NABoolean doPrivCheck = checkUserPrivs(currContext, getMItdb().queryType_);  
            NAString privWhereClause;

            // get active roles for current user and put in a list that can be
            // used in a select "IN" clause.  Include the current user
            NAString authList;
            if (CmpCommon::context()->isAuthorizationEnabled())
            {
               // always include the current user in the list of auth IDs
               char authIDAsChar[sizeof(Int32)+10];
               str_sprintf(authIDAsChar, "(%d", *currContext->getDatabaseUserID());
               authList += authIDAsChar;

               // add list of roles stored in context
               Int32 numRoles;
               Int32 *roleList;
               if (currContext->getRoleList(numRoles, roleList) != SUCCESS)
                 numRoles = 0;
               for (Int32 i = 0; i < numRoles; i++)
               {
                 authList += ", ";
                 str_sprintf(authIDAsChar, "%d", roleList[i]);
                 authList += authIDAsChar;
               } 
               authList += ")";
            }

            // If request to get privilege information but authorization tables were not initialized,
	    if(getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::COMPONENTS_
	      ||getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::COMPONENT_OPERATIONS_
	      ||getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::COMPONENT_PRIVILEGES_
              ||getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::USERS_FOR_ROLE_
              ||getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::ROLES_FOR_USER_
              ||getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::PRIVILEGES_FOR_ROLE_
              ||getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::PRIVILEGES_FOR_USER_)
	    {
               if (!CmpCommon::context()->isAuthorizationEnabled())
               {
                  ComDiagsArea * diags = getDiagsArea();
                  *diags << DgSqlCode(-CAT_AUTHORIZATION_NOT_ENABLED);
                  step_ = HANDLE_ERROR_;
                  break;
               }
            }

	    switch (getMItdb().queryType_)
	      {
	      case ComTdbExeUtilGetMetadataInfo::TABLES_IN_SCHEMA_:
		{
		  qs = getTrafTablesInSchemaQuery;
		  sizeOfqs = sizeof(getTrafTablesInSchemaQuery);

                  param_[0] = catSchValue;
                  param_[1] = endQuote;
		  param_[2] = cat;
		  param_[3] = sch;
		  param_[4] = tab;
		  param_[5] = getMItdb().cat_;
		  param_[6] = getMItdb().sch_;
		}
	      break;
	      
	      case ComTdbExeUtilGetMetadataInfo::INDEXES_IN_SCHEMA_:
		{
		  qs = getTrafIndexesInSchemaQuery;
		  sizeOfqs = sizeof(getTrafIndexesInSchemaQuery);

		  param_[0] = cat;
		  param_[1] = sch;
		  param_[2] = tab;
		  param_[3] = getMItdb().cat_;
		  param_[4] = getMItdb().sch_;
		}
	      break;
	      
	      case ComTdbExeUtilGetMetadataInfo::VIEWS_IN_CATALOG_:
		{
		  qs = getTrafViewsInCatalogQuery;
		  sizeOfqs = sizeof(getTrafViewsInCatalogQuery);

		  param_[0] = cat;
		  param_[1] = sch;
		  param_[2] = tab;
		  param_[3] = cat;
		  param_[4] = sch;
		  param_[5] = view;
		  param_[6] = getMItdb().cat_;
		}
	      break;
	      
	      case ComTdbExeUtilGetMetadataInfo::VIEWS_IN_SCHEMA_:
		{
		  qs = getTrafViewsInSchemaQuery;
		  sizeOfqs = sizeof(getTrafViewsInSchemaQuery);

		  param_[0] = cat;
		  param_[1] = sch;
		  param_[2] = tab;
		  param_[3] = cat;
		  param_[4] = sch;
		  param_[5] = view;
		  param_[6] = getMItdb().cat_;
		  param_[7] = getMItdb().sch_;
		}
	      break;

	      case ComTdbExeUtilGetMetadataInfo::TABLES_IN_VIEW_:
	      case ComTdbExeUtilGetMetadataInfo::VIEWS_IN_VIEW_:
	      case ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_VIEW_:
		{
		  qs = getTrafObjectsInViewQuery;
		  sizeOfqs = sizeof(getTrafObjectsInViewQuery);

		  param_[0] = cat;
		  param_[1] = sch;
		  param_[2] = view_usage;
		  param_[3] = cat;
		  param_[4] = sch;
		  param_[5] = tab;
		  param_[6] = cat;
		  param_[7] = sch;
		  param_[8] = tab;
		  param_[9] = getMItdb().cat_;
		  param_[10] = getMItdb().sch_;
		  param_[11] = getMItdb().obj_;

                  numOutputEntries_ = 2;
		}
	      break;

              case ComTdbExeUtilGetMetadataInfo::INDEXES_ON_TABLE_:
                {
		  qs = getTrafIndexesOnTableQuery;
		  sizeOfqs = sizeof(getTrafIndexesOnTableQuery);

		  param_[0] = catSchValue;
		  param_[1] = endQuote;
		  param_[2] = cat;
		  param_[3] = sch;
		  param_[4] = indexes;
		  param_[5] = cat;
		  param_[6] = sch;
		  param_[7] = tab;
		  param_[8] = cat;
		  param_[9] = sch;
		  param_[10] = tab;
		  param_[11] = getMItdb().cat_;
		  param_[12] = getMItdb().sch_;
		  param_[13] = getMItdb().obj_;

                }
                break;

	      case ComTdbExeUtilGetMetadataInfo::VIEWS_ON_TABLE_:
	      case ComTdbExeUtilGetMetadataInfo::VIEWS_ON_VIEW_:
		{
		  qs = getTrafViewsOnObjectQuery;
		  sizeOfqs = sizeof(getTrafViewsOnObjectQuery);

		  param_[0] = cat;
		  param_[1] = sch;
		  param_[2] = tab;
		  param_[3] = cat;
		  param_[4] = sch;
		  param_[5] = view_usage;
		  param_[6] = cat;
		  param_[7] = sch;
		  param_[8] = tab;
		  param_[9] = getMItdb().cat_;
		  param_[10] = getMItdb().sch_;
		  param_[11] = getMItdb().obj_;

		  if (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::VIEWS_ON_TABLE_)
		    strcpy(ausStr, " and T1.object_type = 'BT' ");
		  param_[12] = ausStr;
		}
	      break;

	      case ComTdbExeUtilGetMetadataInfo::SCHEMAS_IN_CATALOG_:
		{
		  qs = getTrafSchemasInCatalogQuery;
		  sizeOfqs = sizeof(getTrafSchemasInCatalogQuery);

		  param_[0] = cat;
		  param_[1] = sch;
		  param_[2] = tab;
		  param_[3] = getMItdb().cat_;
		}
	      break;
              case ComTdbExeUtilGetMetadataInfo::SCHEMAS_FOR_USER_:
		{
		  qs = getTrafSchemasForAuthIDQuery;
		  sizeOfqs = sizeof(getTrafSchemasForAuthIDQuery);

		  param_[0] = cat;
		  param_[1] = sch;
		  param_[2] = tab;
		  param_[3] = cat;
		  param_[4] = sch;
		  param_[5] = auths;
		  param_[6] = getMItdb().getParam1();
		}
	      break;
              case ComTdbExeUtilGetMetadataInfo::USERS_:
                {
                  qs = getTrafUsers;
                  sizeOfqs = sizeof(getTrafUsers);

                  if (doPrivCheck)
                  {
                     char buf[authList.length() + 100];
                     str_sprintf(buf, " and auth_id in %s", authList.data());
                     privWhereClause = buf;
                  }

                  param_[0] = cat;
                  param_[1] = sch;
                  param_[2] = auths;
                  param_[3] = (char *) privWhereClause.data();
		}
                break;
              case ComTdbExeUtilGetMetadataInfo::PROCEDURES_IN_SCHEMA_:
                {
                  qs = getTrafProceduresInSchemaQuery;
                  sizeOfqs = sizeof(getTrafProceduresInSchemaQuery);

		  param_[0] = cat;
		  param_[1] = sch;
		  param_[2] = tab;
                  param_[3] = cat;
		  param_[4] = sch;
		  param_[5] = routine;
		  param_[6] = getMItdb().cat_;
		  param_[7] = getMItdb().sch_;
                }
                break ;
              case ComTdbExeUtilGetMetadataInfo::LIBRARIES_IN_SCHEMA_:
                {
                  qs = getTrafLibrariesInSchemaQuery;
                  sizeOfqs = sizeof(getTrafLibrariesInSchemaQuery);

		  param_[0] = cat;
		  param_[1] = sch;
		  param_[2] = tab;
		  param_[3] = getMItdb().cat_;
		  param_[4] = getMItdb().sch_;
                }
                break ;
              case ComTdbExeUtilGetMetadataInfo::FUNCTIONS_IN_SCHEMA_:
                {
                  qs = getTrafFunctionsInSchemaQuery;
                  sizeOfqs = sizeof(getTrafFunctionsInSchemaQuery);

		  param_[0] = cat;
		  param_[1] = sch;
		  param_[2] = tab;
                  param_[3] = cat;
		  param_[4] = sch;
		  param_[5] = routine;
		  param_[6] = getMItdb().cat_;
		  param_[7] = getMItdb().sch_;
                }
                break ;
	      case ComTdbExeUtilGetMetadataInfo::TABLE_FUNCTIONS_IN_SCHEMA_:
                {
                  qs = getTrafTableFunctionsInSchemaQuery;
                  sizeOfqs = sizeof(getTrafTableFunctionsInSchemaQuery);

		  param_[0] = cat;
		  param_[1] = sch;
		  param_[2] = tab;
                  param_[3] = cat;
		  param_[4] = sch;
		  param_[5] = routine;
		  param_[6] = getMItdb().cat_;
		  param_[7] = getMItdb().sch_;
                }
                break ;
              case ComTdbExeUtilGetMetadataInfo::PROCEDURES_FOR_LIBRARY_:
              case ComTdbExeUtilGetMetadataInfo::FUNCTIONS_FOR_LIBRARY_:
              case ComTdbExeUtilGetMetadataInfo::TABLE_FUNCTIONS_FOR_LIBRARY_:
                {
                  qs = getTrafProceduresForLibraryQuery;
                  sizeOfqs = sizeof(getTrafProceduresForLibraryQuery);

		  param_[0] = cat;
		  param_[1] = sch;
		  param_[2] = tab;
                  param_[3] = cat;
		  param_[4] = sch;
		  param_[5] = routine;
                  param_[6] = cat;
		  param_[7] = sch;
		  param_[8] = library_usage;
                  param_[9] = cat;
		  param_[10] = sch;
		  param_[11] = tab;
                  param_[12] = getMItdb().cat_;
		  param_[13] = getMItdb().sch_;
		  param_[14] = getMItdb().obj_;
                  if (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::PROCEDURES_FOR_LIBRARY_)
		    strcpy(ausStr, " R.udr_type = 'P ' ");
                  else if (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::FUNCTIONS_FOR_LIBRARY_)
		    strcpy(ausStr, " R.udr_type = 'F ' ");
                   else
		    strcpy(ausStr, " R.udr_type = 'T ' ");
		  param_[15] = ausStr;
                }
                break ;
                
              case ComTdbExeUtilGetMetadataInfo::ROLES_:
                {
                  qs = getTrafRoles;

                  sizeOfqs = sizeof(getTrafRoles);

                  if (doPrivCheck)
                  {
                     char buf[authList.length() + 100];
                     str_sprintf(buf, " and auth_id in %s", authList.data());
                     privWhereClause = buf;
                  }

                  param_[0] = cat;
                  param_[1] = sch;
                  param_[2] = auths;
                  param_[3] = (char *) privWhereClause.data();
                }
              break;

              case ComTdbExeUtilGetMetadataInfo::USERS_FOR_ROLE_:
                {
                  qs = getUsersForRoleQuery;
                  sizeOfqs = sizeof(getUsersForRoleQuery);
                  
                  // return the name if the role has been granted to the current user
                  if (doPrivCheck)  
                     privWhereClause = " and grantee_name = CURRENT_USER ";

                  param_[0] = cat;
                  param_[1] = pmsch;
                  param_[2] = role_usage;
                  param_[3] = getMItdb().getParam1();
                  param_[4] = (char *) privWhereClause.data();
                }
              break;
                
              case ComTdbExeUtilGetMetadataInfo::ROLES_FOR_USER_:
                {
                  qs = getRolesForUserQuery;
                  sizeOfqs = sizeof(getRolesForUserQuery);
                  
                  // return the name if the current user was granted the role
                  if (doPrivCheck)  
                     privWhereClause = " and CURRENT_USER=RU.grantee_name ";

                  param_[0] = cat;
                  param_[1] = pmsch;
                  param_[2] = role_usage;
                  param_[3] = getMItdb().getParam1();
                  param_[4] = (char *) privWhereClause.data();
                }
              break;
              
              case ComTdbExeUtilGetMetadataInfo::PRIVILEGES_FOR_ROLE_:
              case ComTdbExeUtilGetMetadataInfo::PRIVILEGES_FOR_USER_:
                {
                  NABoolean isRole = 
                     (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::PRIVILEGES_FOR_ROLE_); 
              
                  // Get the authID associated with the current user
                  Int32 authID = getAuthID(getMItdb().getParam1(), cat, sch, auths);

                  // If the authID was not found for various reasons just return
                  // Other "get" commands continue and return no rows but it is
                  // easier to just return with an error.
                  if (authID == 0)
                    { 
                      ComDiagsArea * diags = getDiagsArea();
                      *diags << DgSqlCode(-8732)
                             << DgString0(getMItdb().getParam1());
                      step_ = HANDLE_ERROR_;
                      break;
                    }

                  if (isRole)
                    {
                       // treating PUBLIC (-1) as a role in this instance, return
                       // error if authID is not a role
                       if (!CmpSeabaseDDLauth::isRoleID(authID) && authID != PUBLIC_USER)
                        {
                          ComDiagsArea * diags = getDiagsArea();
                          *diags << DgSqlCode(-CAT_IS_NOT_A_ROLE)
                                 << DgString0(getMItdb().getParam1());
                          step_ = HANDLE_ERROR_;
                          break;
                        }
                    }

                  else
                    {
                      // Return an error if authID is not a user
                      if (!CmpSeabaseDDLauth::isUserID(authID))
                        {
                          ComDiagsArea * diags = getDiagsArea();
                          *diags << DgSqlCode(-CAT_IS_NOT_A_USER)
                                 << DgString0(getMItdb().getParam1());
                          step_ = HANDLE_ERROR_;
                          break;
                        }
                    }
               
                  qs = getPrivsForAuthsQuery;
                  sizeOfqs = sizeof(getPrivsForAuthsQuery);

                  char buf[authList.length() + 100];
                  if (isRole)
                  {
                    if (doPrivCheck)
                      // Only return name if current user has been
                      // granted the role
                      str_sprintf(buf, " = %d and %d in %s ", 
                                  authID, authID, authList.data());
                    else
                      // return all role grantees
                      str_sprintf(buf, " = %d ", authID );
                  }
                  else
                  {
                    if (doPrivCheck)
                    {
                      // If asking for privileges for a user other than CURRENT_USER, 
                      // use -2 (special user called _SYSTEM), privileges can never 
                      // be granted to _SYSTEM. This returns an empty list 
                      // which match other "get" statements behavior.
                      if (strcmp(getMItdb().getParam1(), currContext->getDatabaseUserName()) != 0)
                        str_sprintf(buf, " = -2 ");
                      else
                       // return all privs for the user and the users roles
                       str_sprintf(buf, " in %s ", authList.data());
                    }

                    else
                      if (*currContext->getDatabaseUserID() == authID)
                        str_sprintf(buf, " in %s ", authList.data());
                      else
                        {
                          // If getting privileges for a user other than the CURRENT USER,
                          // get the list of roles for this other user.
                          char *userRoleList = getRoleList(authID, cat, pmsch, role_usage);
                          if (userRoleList)
                          {
                            str_sprintf(buf, " in %s ", userRoleList);
                            NADELETEBASIC(userRoleList, getHeap());
                          }
                          else 
                            str_sprintf(buf, " = %d ", authID);
                        }
                  }
                  privWhereClause = buf;

                  // Union privileges between object, column and schema
                  param_[0] = cat;
                  param_[1] = pmsch;
                  param_[2] = objPrivs;
                  param_[3] = (char *) privWhereClause.data();
                  param_[4] = cat;
                  param_[5] = pmsch;
                  param_[6] = colPrivs;
                  param_[7] = cat;
                  param_[8] = sch;
                  param_[9] = col;
                  param_[10] = (char *) privWhereClause.data();
                  param_[11] = cat;
                  param_[12] = pmsch;
                  param_[13] = schPrivs;
                  param_[14] = (char *) privWhereClause.data();

                  numOutputEntries_ = 2;
                }
              break;

              case ComTdbExeUtilGetMetadataInfo::COMPONENTS_:
              {
                qs = getComponents;
                sizeOfqs = sizeof(getComponents);

                if (doPrivCheck)
                  {
                     char buf[authList.length() + 100];
                     str_sprintf(buf, " and p.grantee_id in %s", authList.data());
                     privWhereClause = buf;
                  }

                param_[0] = cat;
                param_[1] = pmsch;
                param_[2] = components;
                param_[3] = cat;
                param_[4] = pmsch;
                param_[5] = componentPrivileges;
                param_[6] = (char *) privWhereClause.data();
              }
              break;

              case ComTdbExeUtilGetMetadataInfo::COMPONENT_PRIVILEGES_:
              {
                 qs = getComponentPrivileges;
                 sizeOfqs = sizeof(getComponentPrivileges);

                 // Get privileges for auth name
                 if (getMItdb().getParam1()) 
                 {
                    // Get the authID associated with the request's auth name
                    // If can't find authID, NA_UserIdDefault is returned which 
                    // indicates an invalid authID.
                    Int32 authID = getAuthID(getMItdb().getParam1(), cat, sch, auths);

                    if (doPrivCheck)
                    {
                       // If asking for privileges for a user that has no privs
                       //   authName is invalid
                       //   authName is a user and not the current user
                       //   authName is a role and not one of the current user roles
                       // add a predicate to make operation fail with no rows
                       // This matches other "get" statement's behavior.
                       NABoolean hasPriv = TRUE;
                       if ((authID == NA_UserIdDefault) ||
                           (CmpSeabaseDDLauth::isUserID(authID) &&
                             (strcmp(getMItdb().getParam1(), currContext->getDatabaseUserName()) != 0)) || 
                           (CmpSeabaseDDLauth::isRoleID(authID) &&
                             !ComUser::currentUserHasRole(authID)))
                       {
                          privWhereClause += "and (grantee_id = -2) ";
                          hasPriv = FALSE;
                       }
                       if (hasPriv)
                       {
                          privWhereClause += "and (grantee_name = '";
                          privWhereClause += getMItdb().getParam1();
                          privWhereClause += "'";
                          if (CmpSeabaseDDLauth::isUserID(authID) && getMItdb().cascade())
                          {
                              privWhereClause += " or grantee_id in ";
                              privWhereClause += authList.data();
                          }
                          privWhereClause += ")";
                       }
                    }
                    else
                    { 
                       privWhereClause += "and (grantee_name = '";
                       privWhereClause += getMItdb().getParam1();
                       privWhereClause += "'";

                       // if authname is a user and specified cascade, include roles
                       if (CmpSeabaseDDLauth::isUserID(authID) && getMItdb().cascade())
                       {
                          char buf[300 + MAX_AUTHNAME_LEN + 200];
                          str_sprintf(buf, "or p.grantee_id = (select role_id from "
                                           "%s.\"%s\".%s where grantee_name = '%s') "
                                           "or p.grantee_id = -1",
                                      cat, pmsch, role_usage, getMItdb().getParam1());
                          privWhereClause += buf;
                       }
                       privWhereClause += ')';  
                    }
                 }

                 // no specific authname specified, get current users results
                 else
                 {
                    // Limit results to current user and current users roles
                    if (getMItdb().cascade())
                    {
                       privWhereClause += " and p.grantee_id in ";
                       privWhereClause += authList.data();
                    }
                    // limit results to current user
                    else
                    {
                       privWhereClause += " and p.grantee_name = '";
                       privWhereClause += currContext->getDatabaseUserName();
                       privWhereClause += "'";
                    }
                 }

                 param_[0] = cat;
                 param_[1] = pmsch;
                 param_[2] = components;
                 param_[3] = cat;
                 param_[4] = pmsch;
                 param_[5] = componentOperations;
                 param_[6] = cat;
                 param_[7] = pmsch;
                 param_[8] = componentPrivileges;
                 param_[9] = getMItdb().getObj();
                 param_[10] = (char *) privWhereClause.data();
              }
              break;

              case ComTdbExeUtilGetMetadataInfo::SEQUENCES_IN_CATALOG_:
                {
                  qs = getTrafSequencesInCatalogQuery;
                  sizeOfqs = sizeof(getTrafSequencesInCatalogQuery);

		  param_[0] = cat;
		  param_[1] = sch;
		  param_[2] = tab;
		  param_[3] = getMItdb().cat_;
                }
                break ;

              case ComTdbExeUtilGetMetadataInfo::SEQUENCES_IN_SCHEMA_:
                {
                  qs = getTrafSequencesInSchemaQuery;
                  sizeOfqs = sizeof(getTrafSequencesInSchemaQuery);

		  param_[0] = cat;
		  param_[1] = sch;
		  param_[2] = tab;
		  param_[3] = getMItdb().cat_;
		  param_[4] = getMItdb().sch_;
                }
                break ;

	      default:
		{
		  ExHandleErrors(qparent_,
				 pentry_down,
				 0,
				 getGlobals(),
				 NULL,
				 (ExeErrorCode)-4218,
				 NULL,
				 "GET"
				 );
		  step_ = HANDLE_ERROR_;
		}
		break;
	      }
         
             if (step_ == HANDLE_ERROR_)
               break;

	     Int32 qryArraySize = sizeOfqs / sizeof(QueryString);
	     char * gluedQuery;
	     Lng32 gluedQuerySize;
	     glueQueryFragments(qryArraySize, qs, 
				gluedQuery, gluedQuerySize);
	     
	     str_sprintf(queryBuf_, gluedQuery,
			 param_[0], param_[1], param_[2], param_[3], param_[4],
			 param_[5], param_[6], param_[7], param_[8], param_[9],
			 param_[10], param_[11], param_[12], param_[13], param_[14], param_[15]);
             NADELETEBASIC(gluedQuery, getMyHeap());	     
	     step_ = FETCH_ALL_ROWS_;
	  }
	  break;

	case FETCH_ALL_ROWS_:
	  {
	    if (initializeInfoList(infoList_))
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    if (fetchAllRows(infoList_, queryBuf_, numOutputEntries_,
			     FALSE, retcode) < 0)
	      {
		cliInterface()->retrieveSQLDiagnostics(getDiagsArea());

		step_ = HANDLE_ERROR_;

		break;
	      }

	    infoList_->position();

	    step_ = RETURN_ROW_;
	  }
	break;

	case RETURN_ROW_:
	  {
	    if (infoList_->atEnd())
	      {
		step_ = ENABLE_CQS_;
		break;
	      }

	    if (qparent_.up->isFull())
	      return WORK_OK;

	    OutputInfo * vi = (OutputInfo*)infoList_->getCurr();

	    char * ptr = vi->get(0);
	    short len = (short)(ptr ? strlen(ptr) : 0);
 
	    exprRetCode = ex_expr::EXPR_TRUE;

            if ((getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::PRIVILEGES_FOR_USER_) ||
                (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::PRIVILEGES_FOR_ROLE_))
            {
              // output:  privileges<4spaces>object name
              NAString outputStr (vi->get(1));
              outputStr += "    ";
              outputStr += ptr;
  
              char * outputCharStr = new char[outputStr.length() + 1];
              memset (outputCharStr,'\0', outputStr.length() + 1);
              str_cpy_all(outputCharStr, outputStr.data(), outputStr.length());
              ptr = outputCharStr;
              len = outputStr.length();
            }
	    if ((getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::TRIGTEMP_TABLE_ON_TABLE_ ) || 
		(getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::TRIGTEMP_TABLE_ON_MV_ ))
	      {
		//append __TEMP to the name
		short len1 = strlen(ptr);
		char *nameString = new char[len1+7+1];
	        memset(nameString,'\0',len1+7+1);
		ComBoolean isQuoted = FALSE;
	
		str_cpy_all(nameString, vi->get(0),len1);
		if ( '"' == nameString[ len1 - 1 ] )
		  {
		    isQuoted = TRUE;
		  }
		if (isQuoted)
		  str_cpy_all(&nameString[len1-1],"__TEMP\"",8);
		else
		  str_cpy_all(&nameString[len1],"__TEMP",6);
		
		ptr = nameString;
		if (isQuoted)
		  len = len1+7;
		else
		  len = len1+6;

			    
	      }
	    if (((getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::TABLES_IN_VIEW_) ||
		 (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::TABLES_IN_MV_)) &&
		(vi->get(1) && (strcmp(vi->get(1), "BT") != 0)))
	      exprRetCode = ex_expr::EXPR_FALSE;
	    else if ((getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::VIEWS_IN_VIEW_) &&
		(vi->get(1) && (strcmp(vi->get(1), "VI") != 0)))
	      exprRetCode = ex_expr::EXPR_FALSE;
	    else if ((getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::MVS_IN_MV_) &&
		(vi->get(1) && (strcmp(vi->get(1), "MV") != 0)))
	      exprRetCode = ex_expr::EXPR_FALSE;

	    if (exprRetCode == ex_expr::EXPR_TRUE)
	      exprRetCode = evalScanExpr(ptr, len, TRUE);
	    if (exprRetCode == ex_expr::EXPR_FALSE)
	      {
		// row does not pass the scan expression,
		// move to the next row.
		infoList_->advance();
		break;
	      }
	    else if (exprRetCode == ex_expr::EXPR_ERROR)
	     {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    if (NOT headingReturned_)
	      {
		step_ = DISPLAY_HEADING_;
		break;
	      }

            // if returned table name is an external name, convert it to the native name.
            // Do it for tables_in_view and objects_in_view operations only.
            NAString nativeName;
	    if (((getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::TABLES_IN_VIEW_) ||
		 (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_VIEW_)) &&
		(vi->get(1) && (strcmp(vi->get(1), "BT") == 0)))
              {
                char tempBuf[2*len];
                Lng32 numParts = 0;
                char *parts[4];
                LateNameInfo::extractParts(ptr, tempBuf, numParts, parts, TRUE);
                if (numParts == 3)
                  {
                    NAString catName(parts[0]);
                    NAString schName(parts[1]);
                    NAString objName(parts[2]);
                    if (ComIsTrafodionExternalSchemaName(schName))
                      {
                        ComObjectName tableName(catName,
                                                schName,
                                                objName,
                                                COM_TABLE_NAME);
                        
                        nativeName =
                          ComConvertTrafNameToNativeName
                          (tableName.getCatalogNamePartAsAnsiString(),
                           tableName.getSchemaNamePartAsAnsiString(),
                           tableName.getObjectNamePartAsAnsiString());
                        ptr = (char*)nativeName.data();
						len = nativeName.length();
                      }
                  }
              }

	    short rc = 0;
	    if (moveRowToUpQueue(ptr, len, &rc))
            {
	      return rc;
            }

	    infoList_->advance();
	  }
	break;

	case DISPLAY_HEADING_:
	  {
	    retcode = displayHeading();
	    if (retcode == 1)
	      return WORK_OK;
	    else if (retcode < 0)
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    headingReturned_ = TRUE;

	    step_ = RETURN_ROW_;
	  }
	break;

	case ENABLE_CQS_:
	  {
	    if (restoreCQS())
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    if ((getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::VIEWS_ON_TABLE_) ||
		(getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::VIEWS_ON_VIEW_) ||
		(getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::MVS_ON_TABLE_) ||
		(getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::MVS_ON_VIEW_))

	      step_ = GET_USING_VIEWS_;
	    else if ((getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::TABLES_IN_VIEW_) ||
		     (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::VIEWS_IN_VIEW_) ||
		     (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_VIEW_) ||
		     (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::TABLES_IN_MV_) ||
		     (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::MVS_IN_MV_) ||
		     (getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_MV_))
	      step_ = GET_USED_OBJECTS_;
	    else
	      step_ = DONE_;
	  }
	break;

	case GET_USING_VIEWS_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    if (NOT getMItdb().allObjs())
	      {
		step_ = DONE_;
		break;
	      }

	    char * viewName = NULL;
	    Lng32 len = 0;
	    if ((getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::VIEWS_ON_TABLE_) ||
		(getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::VIEWS_ON_VIEW_))
	      cliRC = getUsingView(infoList_, TRUE, viewName, len);
	    else
	      cliRC = getUsingView(infoList_, FALSE, viewName, len);

	    if (cliRC == 100)
	      {
		step_ = DONE_;
		break;
	      }
	    else if (cliRC < 0)
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    exprRetCode = evalScanExpr(viewName, len, TRUE);
	    if (exprRetCode == ex_expr::EXPR_FALSE)
	      {
		// row does not pass the scan expression,
		// move to the next row.
		break;
	      }
	    else if (exprRetCode == ex_expr::EXPR_ERROR)
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    short rc = 0;
	    moveRowToUpQueue(viewName, len, &rc);
	  }
	break;

	case GET_USED_OBJECTS_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    if (NOT getMItdb().allObjs())
	      {
		step_ = DONE_;
		break;
	      }

	    char * viewName = NULL;
	    Lng32 len = 0;
	    if ((getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::TABLES_IN_VIEW_) ||
		(getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::VIEWS_IN_VIEW_) ||
		(getMItdb().queryType_ == ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_VIEW_))
	      cliRC = getUsedObjects(infoList_, TRUE, viewName, len);
	    else
	      cliRC = getUsedObjects(infoList_, FALSE, viewName, len);

	    if (cliRC == 100)
	      {
		step_ = DONE_;
		break;
	      }
	    else if (cliRC < 0)
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    exprRetCode = evalScanExpr(viewName, len, TRUE);
	    if (exprRetCode == ex_expr::EXPR_FALSE)
	      {
		// row does not pass the scan expression,
		// move to the next row.
		break;
	      }
	    else if (exprRetCode == ex_expr::EXPR_ERROR)
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    short rc = 0;
	    moveRowToUpQueue(viewName, len, &rc);
	  }
	break;

	case HANDLE_ERROR_:
	  {
	    restoreCQS();

	    retcode = handleError();
	    if (retcode == 1)
	      {
		return WORK_OK;
	      } // if (retcode
	    
	    step_ = DONE_;
	  }
	break;

	case DONE_:
	  {
	    retcode = handleDone();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = INITIAL_;

	    return WORK_OK;
	  }
	break;

	}

    }

  return 0;
}

////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilGetMetadataInfoComplexTcb
///////////////////////////////////////////////////////////////
ExExeUtilGetMetadataInfoComplexTcb::ExExeUtilGetMetadataInfoComplexTcb(
     const ComTdbExeUtilGetMetadataInfo & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilGetMetadataInfoTcb( exe_util_tdb, glob)
{
}

ExExeUtilGetMetadataInfoComplexTcb::~ExExeUtilGetMetadataInfoComplexTcb()
{
}

//////////////////////////////////////////////////////
// work() for ExExeUtilGetMetadataInfoComplexTcb
//////////////////////////////////////////////////////
short ExExeUtilGetMetadataInfoComplexTcb::work()
{
  short retcode = 0;
  Lng32 cliRC = 0;
  ex_expr::exp_return_type exprRetCode = ex_expr::EXPR_OK;

  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;

  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;

  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getStatement()->getContext();

  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
	    step_ = SETUP_QUERY_;
	  }
	break;

	case SETUP_QUERY_:
	  {
	    str_sprintf(patternStr_, "");
	    if (getMItdb().getPattern())
	      {
		str_sprintf(patternStr_, ", match '%s' ",
			    getMItdb().getPattern());
	      }

	    step_ = FETCH_ALL_ROWS_;

	    char rfn[200];
	    if (getMItdb().returnFullyQualNames())
	      strcpy(rfn, ", return full names ");
	    else
	      strcpy(rfn, " ");

	    switch (getMItdb().queryType_)
	      {
	      case ComTdbExeUtilGetMetadataInfo::VIEWS_ON_TABLE_:
		{
		  str_sprintf(queryBuf_, "select * from (get all views on table \"%s\".\"%s\".\"%s\", no header %s %s) x(a) group by a order by 1",
			      getMItdb().getCat(), getMItdb().getSch(), getMItdb().getObj(),
			      rfn,
			      patternStr_);
		}
	      break;

	      case ComTdbExeUtilGetMetadataInfo::VIEWS_ON_VIEW_:
		{
		  str_sprintf(queryBuf_, "select * from (get all views on view \"%s\".\"%s\".\"%s\", no header %s %s) xxx(aaa) group by aaa order by 1",
			      getMItdb().getCat(), getMItdb().getSch(), getMItdb().getObj(),
			      rfn,
			      patternStr_);
		}
	      break;

	      case ComTdbExeUtilGetMetadataInfo::MVS_ON_TABLE_:
		{
		  str_sprintf(queryBuf_, "select * from (get all mvs on table \"%s\".\"%s\".\"%s\", no header %s) xxx(aaa) group by aaa order by 1",
			      getMItdb().getCat(), getMItdb().getSch(), getMItdb().getObj(),
			      patternStr_);
		}
	      break;

	      case ComTdbExeUtilGetMetadataInfo::MVS_ON_MV_:
		{
		  str_sprintf(queryBuf_, "select * from (get all mvs on mv \"%s\".\"%s\".\"%s\", no header %s) xxx(aaa) group by aaa order by 1",
			      getMItdb().getCat(), getMItdb().getSch(), getMItdb().getObj(),
			      patternStr_);
		}
	      break;

	      case ComTdbExeUtilGetMetadataInfo::TABLES_IN_VIEW_:
		{
		  str_sprintf(queryBuf_, "select * from (get all tables in view \"%s\".\"%s\".\"%s\", no header %s) xxx(aaa) group by aaa order by 1",
			      getMItdb().getCat(), getMItdb().getSch(), getMItdb().getObj(),
			      patternStr_);
		}
	      break;

	      case ComTdbExeUtilGetMetadataInfo::VIEWS_IN_VIEW_:
		{
		  str_sprintf(queryBuf_, "select * from (get all views in view \"%s\".\"%s\".\"%s\", no header %s) xxx(aaa) group by aaa order by 1",
			      getMItdb().getCat(), getMItdb().getSch(), getMItdb().getObj(),
			      patternStr_);
		}
	      break;

	      case ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_VIEW_:
		{
		  str_sprintf(queryBuf_, "select * from (get all objects in view \"%s\".\"%s\".\"%s\", no header %s) xxx(aaa) group by aaa order by 1",
			      getMItdb().getCat(), getMItdb().getSch(), getMItdb().getObj(),
			      patternStr_);
		}
	      break;

	      case ComTdbExeUtilGetMetadataInfo::TABLES_IN_MV_:
		{
		  str_sprintf(queryBuf_, "select * from (get all tables in mv \"%s\".\"%s\".\"%s\", no header %s) xxx(aaa) group by aaa order by 1",
			      getMItdb().getCat(), getMItdb().getSch(), getMItdb().getObj(),
			      patternStr_);
		}
	      break;

	      case ComTdbExeUtilGetMetadataInfo::MVS_IN_MV_:
		{
		  str_sprintf(queryBuf_, "select * from (get all mvs in mv \"%s\".\"%s\".\"%s\", no header %s) xxx(aaa) group by aaa order by 1",
			      getMItdb().getCat(), getMItdb().getSch(), getMItdb().getObj(),
			      patternStr_);
		}
	      break;

	      case ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_MV_:
		{
		  str_sprintf(queryBuf_, "select * from (get all objects in mv \"%s\".\"%s\".\"%s\", no header %s) xxx(aaa) group by aaa order by 1",
			      getMItdb().getCat(), getMItdb().getSch(), getMItdb().getObj(),
			      patternStr_);
		}
	      break;

	      case ComTdbExeUtilGetMetadataInfo::OBJECTS_ON_TABLE_:
		{
		  step_ = FETCH_ALL_ROWS_FOR_OBJECTS_;
		}
	      break;

	      case ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_SCHEMA_:
		{
		  step_ = FETCH_ALL_ROWS_IN_SCHEMA_;
		}
	      break;

	      default:
		{
		  ExHandleErrors(qparent_,
				 pentry_down,
				 0,
				 getGlobals(),
				 NULL,
				 (ExeErrorCode)-4218,
				 NULL,
				 "GET"
				 );
		  step_ = HANDLE_ERROR_;
		}
	      break;

	      } // switch
	  }
	break;

	case FETCH_ALL_ROWS_:
	  {
	    if (initializeInfoList(infoList_))
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    if (fetchAllRows(infoList_, queryBuf_, 1, FALSE, retcode) < 0)
	      {
		step_ = HANDLE_ERROR_;

		break;
	      }

	    infoList_->position();

	    step_ = DISPLAY_HEADING_;
	  }
	break;

	case FETCH_ALL_ROWS_FOR_OBJECTS_:
	  {
	    if (initializeInfoList(infoList_))
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    char ausStr[20];
	    strcpy(ausStr, "");
	    if (getMItdb().systemObjs())
	      strcpy(ausStr, "SYSTEM");
	    else if (getMItdb().allObjs())
	      strcpy(ausStr, "ALL");

	    // Get indexes on table
	    str_sprintf(queryBuf_, "get indexes on table \"%s\".\"%s\".\"%s\" %s",
			getMItdb().getCat(), getMItdb().getSch(), getMItdb().getObj(),
			patternStr_);

	    if (fetchAllRows(infoList_, queryBuf_, 1, FALSE, retcode) < 0)
	      {
		step_ = HANDLE_ERROR_;

		break;
	      }

	    NABoolean rowsFound = FALSE;

	    // insert a NULL entry, this will cause a blank row to be returned
	    if (retcode != 100) // some rows were found
	      {
		infoList_->insert((new(getHeap()) OutputInfo(1)));
		rowsFound = TRUE;
	      }

	    // Get views on table
	    str_sprintf(queryBuf_, "get %s views on table \"%s\".\"%s\".\"%s\" %s",
			ausStr,
			getMItdb().getCat(), getMItdb().getSch(), getMItdb().getObj(),
			patternStr_);

	    if (fetchAllRows(infoList_, queryBuf_, 1, FALSE, retcode) < 0)
	      {
		step_ = HANDLE_ERROR_;

		break;
	      }

	    // insert a NULL entry, this will cause a blank row to be returned
	    if (retcode != 100) // some rows were found
	      {
		infoList_->insert((new(getHeap()) OutputInfo(1)));
		rowsFound = TRUE;
	      }

	    // Get mvs on table
	    str_sprintf(queryBuf_, "get %s mvs on table \"%s\".\"%s\".\"%s\" %s",
			ausStr,
			getMItdb().getCat(), getMItdb().getSch(), getMItdb().getObj(),
			patternStr_);

	    if (fetchAllRows(infoList_, queryBuf_, 1, FALSE, retcode) < 0)
	      {
                // if error is 4222 (command not supported), ignore it.
                if (getDiagsArea()->mainSQLCODE() != -4222)
                  {
                    step_ = HANDLE_ERROR_;
                    
                    break;
                  }

                getDiagsArea()->clear();
	      }

	    // insert a NULL entry, this will cause a blank row to be returned
	    if (retcode != 100)
	      {
		infoList_->insert((new(getHeap()) OutputInfo(1)));
		rowsFound = TRUE;
	      }

	    // Get synonyms on table
	    str_sprintf(queryBuf_, "get synonyms on table \"%s\".\"%s\".\"%s\" %s",
			getMItdb().getCat(), getMItdb().getSch(), getMItdb().getObj(),
			patternStr_);

	    if (fetchAllRows(infoList_, queryBuf_, 1, FALSE, retcode) < 0)
	      {
                // if error is 4222 (command not supported), ignore it.
                if (getDiagsArea()->mainSQLCODE() != -4222)
                  {
                    step_ = HANDLE_ERROR_;
                    
                    break;
                  }

                getDiagsArea()->clear();
	      }

	    // insert a NULL entry, this will cause a blank row to be returned
	    if (retcode != 100)
	      {
		infoList_->insert((new(getHeap()) OutputInfo(1)));
		rowsFound = TRUE;
	      }

	    if (rowsFound)
	      infoList_->removeTail();

	    infoList_->position();

	    step_ = RETURN_ROW_;
	  }
	break;

	case FETCH_ALL_ROWS_IN_SCHEMA_:
	  {
	    if (initializeInfoList(infoList_))
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    NABoolean systemObjs = FALSE;
	    char ausStr[20];
	    strcpy(ausStr, "");
	    if (getMItdb().systemObjs())
	      {
		strcpy(ausStr, "SYSTEM");
		systemObjs = TRUE;
	      }
	    else if (getMItdb().allObjs())
	      strcpy(ausStr, "ALL");

	    // Get tables in schema
	    str_sprintf(queryBuf_, "get %s tables in schema \"%s\".\"%s\" %s",
			ausStr,
			getMItdb().getCat(), getMItdb().getSch(),
			patternStr_);

	    retcode = 100;
	    if (fetchAllRows(infoList_, queryBuf_, 1, FALSE, retcode) < 0)
	      {
		step_ = HANDLE_ERROR_;

		break;
	      }

	    NABoolean rowsFound = FALSE;

	    // insert a NULL entry, this will cause a blank row to be returned
	    if (retcode != 100) // some rows were found
	      {
		infoList_->insert((new(getHeap()) OutputInfo(1)));
		rowsFound = TRUE;
	      }

	    // Get indexes in schema
	    str_sprintf(queryBuf_, "get indexes in schema \"%s\".\"%s\" %s",
			getMItdb().getCat(), getMItdb().getSch(),
			patternStr_);

	    retcode = 100;
	    if (NOT systemObjs)
	      {
		if (fetchAllRows(infoList_, queryBuf_, 1, FALSE, retcode) < 0)
		  {
		    step_ = HANDLE_ERROR_;

		    break;
		  }
	      }

	    // insert a NULL entry, this will cause a blank row to be returned
	    if (retcode != 100) // some rows were found
	      {
		infoList_->insert((new(getHeap()) OutputInfo(1)));
		rowsFound = TRUE;
	      }

	    // Get views in schema
	    str_sprintf(queryBuf_, "get views in schema \"%s\".\"%s\" %s",
			getMItdb().getCat(), getMItdb().getSch(),
			patternStr_);

	    retcode = 100;
	    if (NOT systemObjs)
	      {
		if (fetchAllRows(infoList_, queryBuf_, 1, FALSE, retcode) < 0)
		  {
		    step_ = HANDLE_ERROR_;

		    break;
		  }
	      }

	    // insert a NULL entry, this will cause a blank row to be returned
	    if (retcode != 100) // some rows were found
	      {
		infoList_->insert((new(getHeap()) OutputInfo(1)));
		rowsFound = TRUE;
	      }

	    // Get mvs in schema
	    str_sprintf(queryBuf_, "get mvs in schema \"%s\".\"%s\" %s",
			getMItdb().getCat(), getMItdb().getSch(),
			patternStr_);

	    retcode = 100;
	    if (NOT systemObjs)
	      {
		if (fetchAllRows(infoList_, queryBuf_, 1, FALSE, retcode) < 0)
		  {
                    // if error is 4222 (command not supported), ignore it.
                    if (getDiagsArea()->mainSQLCODE() != -4222)
                      {
                        step_ = HANDLE_ERROR_;
                        
                        break;
                      }

                    getDiagsArea()->clear();
		  }
	      }

	    // insert a NULL entry, this will cause a blank row to be returned
	    if (retcode != 100) // some rows were found
	      {
		infoList_->insert((new(getHeap()) OutputInfo(1)));
		rowsFound = TRUE;
	      }

	    // Get synonyms in schema
	    str_sprintf(queryBuf_, "get synonyms in schema \"%s\".\"%s\" %s",
			getMItdb().getCat(), getMItdb().getSch(),
			patternStr_);

	    retcode = 100;
	    if (NOT systemObjs)
	      {
		if (fetchAllRows(infoList_, queryBuf_, 1, FALSE, retcode) < 0)
		  {
                    // if error is 4222 (command not supported), ignore it.
                    if (getDiagsArea()->mainSQLCODE() != -4222)
                      {
                        step_ = HANDLE_ERROR_;
                        
                        break;
                      }

                    getDiagsArea()->clear();
		  }
	      }

	    // insert a NULL entry, this will cause a blank row to be returned
	    if (retcode != 100) // some rows were found
	      {
		infoList_->insert((new(getHeap()) OutputInfo(1)));
		rowsFound = TRUE;
	      }

	    if (rowsFound)
	      infoList_->removeTail();

	    infoList_->position();

	    step_ = RETURN_ROW_;
	  }
	break;

	case DISPLAY_HEADING_:
	  {
	    if (infoList_->atEnd())
	      {
		step_ = DONE_;
		break;
	      }

	    retcode = displayHeading();
	    if (retcode == 1)
	      return WORK_OK;
	    else if (retcode < 0)
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    step_ = RETURN_ROW_;
	  }
	break;

	case RETURN_ROW_:
	  {
	    if (infoList_->atEnd())
	      {
		step_ = DONE_;
		break;
	      }

	    if (qparent_.up->isFull())
	      return WORK_OK;

	    OutputInfo * vi = (OutputInfo*)infoList_->getCurr();

	    short rc = 0;
	    char * ptr = vi->get(0);
	    short len = (short)(ptr ? strlen(ptr) : 0);

	    if (ptr)
	      moveRowToUpQueue(ptr, len, &rc);
	    else
	      moveRowToUpQueue(" ", 0, &rc);

	    infoList_->advance();
	  }
	break;

	case HANDLE_ERROR_:
	  {
	    retcode = handleError();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = DONE_;
	  }
	break;

	case DONE_:
	  {
	    retcode = handleDone();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = INITIAL_;

	    return WORK_OK;
	  }
	break;

	}
    }

  return 0;
}

////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilGetHbaseObjectsTcb
///////////////////////////////////////////////////////////////
ExExeUtilGetHbaseObjectsTcb::ExExeUtilGetHbaseObjectsTcb(
     const ComTdbExeUtilGetMetadataInfo & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilGetMetadataInfoTcb( exe_util_tdb, glob)
{
  int jniDebugPort = 0;
  int jniDebugTimeout = 0;
  ehi_ = ExpHbaseInterface::newInstance(glob->getDefaultHeap(),
					(char*)exe_util_tdb.server(), 
					(char*)exe_util_tdb.zkPort(),
                                        jniDebugPort,
                                        jniDebugTimeout);

  hbaseName_ = NULL;
  hbaseNameBuf_ = new(getGlobals()->getDefaultHeap()) 
    char[ComMAX_3_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES+6+1];
  outBuf_ = new(getGlobals()->getDefaultHeap())
    char[ComMAX_3_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES+6+1];

  hbaseTables_ = NULL;
}

ExExeUtilGetHbaseObjectsTcb::~ExExeUtilGetHbaseObjectsTcb()
{
  if (ehi_)
    delete ehi_;

  if (hbaseNameBuf_)
    NADELETEBASIC(hbaseNameBuf_, getGlobals()->getDefaultHeap());

  if (outBuf_)
    NADELETEBASIC(outBuf_, getGlobals()->getDefaultHeap());
}

//////////////////////////////////////////////////////
// work() for ExExeUtilGetHbaseObjectsTcb
//////////////////////////////////////////////////////
short ExExeUtilGetHbaseObjectsTcb::work()
{
  short retcode = 0;
  Lng32 cliRC = 0;
  ex_expr::exp_return_type exprRetCode = ex_expr::EXPR_OK;

 // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;

  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;
  
  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);
  
  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getStatement()->getContext();
  
  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
            if (ehi_ == NULL)
              {
                step_ = HANDLE_ERROR_;
                break;
              }

            step_ = SETUP_HBASE_QUERY_;
	  }
	break;

        case SETUP_HBASE_QUERY_:
          {
            hbaseTables_ = ehi_->listAll("");
            if (! hbaseTables_)
              {
                step_ = HANDLE_ERROR_;
                break;
              }

            currIndex_ = 0;

            step_ = PROCESS_NEXT_ROW_;
          }
          break;

        case PROCESS_NEXT_ROW_:
          {
            if (currIndex_ == hbaseTables_->entries())
              {
                step_ = DONE_;
                break;
              }

            HbaseStr *hbaseName = &hbaseTables_->at(currIndex_);
            if (hbaseName->len > ComMAX_3_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES+6)
                hbaseName->len = ComMAX_3_PART_EXTERNAL_UTF8_NAME_LEN_IN_BYTES+6; 
            strncpy(hbaseNameBuf_, hbaseName->val, hbaseName->len);
            hbaseNameBuf_[hbaseName->len] = 0;
            hbaseName_ = hbaseNameBuf_;

            Lng32 numParts = 0;
            char *parts[4];
            LateNameInfo::extractParts(hbaseName_, outBuf_, numParts, parts, FALSE);

            currIndex_++;

            if (getMItdb().allObjs())
              {
                step_ = EVAL_EXPR_;
                break;
              }

            NABoolean sysObj = FALSE;
            NABoolean externalObj = FALSE;

            // only trafodion objects will be returned. They are 3-part name that
            // start with TRAFODION.
            if (numParts != 3)
              {
                externalObj = TRUE;
              }
            else
              {
                NAString catalogNamePart(parts[0]);
                NAString schemaNamePart(parts[1]);
                NAString objectNamePart(parts[2]);
                
                if (catalogNamePart != TRAFODION_SYSCAT_LIT)
                  {
                    externalObj = TRUE;
                  }
                else
                  {
                    if (ComIsTrafodionReservedSchema("", catalogNamePart, schemaNamePart))
                      {
                        sysObj = TRUE;
                      }
                  }
              }

            if ((getMItdb().externalObjs()) &&
                (externalObj))
              {
                step_ = EVAL_EXPR_;
                break;
              }
            else if ((getMItdb().systemObjs()) &&
                (sysObj))
              {
                step_ = EVAL_EXPR_;
                break;
              }
            else if ((getMItdb().userObjs()) &&
                     ((NOT sysObj) && (NOT externalObj)))
             {
                step_ = EVAL_EXPR_;
                break;
              }
 
            step_ = PROCESS_NEXT_ROW_;
          }
          break;

        case EVAL_EXPR_:
          {
            exprRetCode = evalScanExpr(hbaseName_, strlen(hbaseName_), TRUE);
	    if (exprRetCode == ex_expr::EXPR_FALSE)
	      {
		// row does not pass the scan expression,
		// move to the next row.
		step_ = PROCESS_NEXT_ROW_;
		break;
	      }
            
            step_ = RETURN_ROW_;
          }
          break;

        case RETURN_ROW_:
          {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    short rc = 0;
	    moveRowToUpQueue(hbaseName_, 0, &rc);

            step_ = PROCESS_NEXT_ROW_;
          }
          break;

	case HANDLE_ERROR_:
	  {
	    retcode = handleError();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = DONE_;
	  }
	break;

	case DONE_:
	  {
            if (hbaseTables_ != NULL) {
               deleteNAArray(getHeap(), hbaseTables_);
               hbaseTables_ = NULL;
            }
	    retcode = handleDone();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = INITIAL_;

	    return WORK_OK;
	  }
	break;
        }
    }

  return WORK_OK;
}

////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilGetMetadataInfoVersionTcb
///////////////////////////////////////////////////////////////
ExExeUtilGetMetadataInfoVersionTcb::ExExeUtilGetMetadataInfoVersionTcb(
     const ComTdbExeUtilGetMetadataInfo & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilGetMetadataInfoTcb( exe_util_tdb, glob)
{
}

static const QueryString getVersionForSchemasInCatalogQuery[] =
{
  {" select translate(trim(S.schema_name) using ucs2toutf8), "},
  {" cast(S.schema_version as char(4)) "},
  {"   from  "},
  {"     HP_SYSTEM_CATALOG.system_schema.catsys C, "},
  {"     HP_SYSTEM_CATALOG.system_schema.schemata S "},
  {"   where "},
  {"     C.cat_name = '%s' and "},
  {"     C.cat_uid = S.cat_uid "},
  {"     %s "},
  {"   order by 1 "},
  {" ; "}
};

static const QueryString getVersionForObjectsInSchemaQuery[] =
{
  {" select translate(trim(O.object_name) using ucs2toutf8), "},
  {" cast(S.schema_version as char(4)), cast(O.object_feature_version as char(4)), "},
  {" cast(O.rcb_version as char(4)) "},
  {"   from  "},
  {"     HP_SYSTEM_CATALOG.system_schema.catsys C, "},
  {"     HP_SYSTEM_CATALOG.system_schema.schemata S, "},
  {"     \"%s\".HP_DEFINITION_SCHEMA.objects O "},
  {"   where "},
  {"     C.cat_name = '%s' and "},
  {"     S.schema_name = '%s' and "},
  {"     C.cat_uid = S.cat_uid and "},
  {"     S.schema_uid = O.schema_uid "},
  {"     %s "},
  {"     order by 1 "},
  {" ; "}
};

//////////////////////////////////////////////////////
// work() for ExExeUtilGetMetadataInfoVersionTcb
//////////////////////////////////////////////////////
short ExExeUtilGetMetadataInfoVersionTcb::work()
{
  short retcode = 0;
  Lng32 cliRC = 0;
  ex_expr::exp_return_type exprRetCode = ex_expr::EXPR_OK;

  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;

  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;

  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getStatement()->getContext();

  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
	    step_ = DISABLE_CQS_;
	  }
	break;

	case DISABLE_CQS_:
	  {
	    if (disableCQS())
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    step_ = SETUP_QUERY_;
	  }
	break;

	case SETUP_QUERY_:
	  {
	    const QueryString * qs;
	    Int32 sizeOfqs = 0;

	    char predStr[2000];
	    str_sprintf(predStr, "");

	    str_sprintf(patternStr_, "");
	    if (getMItdb().getPattern())
	      {
		str_sprintf(patternStr_, ", match '%s' ",
			    getMItdb().getPattern());
	      }

	    if (getMItdb().queryType() == ComTdbExeUtilGetMetadataInfo::SCHEMAS_IN_CATALOG_)
	      {
		qs = getVersionForSchemasInCatalogQuery;
		sizeOfqs = sizeof(getVersionForSchemasInCatalogQuery);

		param_[0] = getMItdb().cat_;
		param_[1] = predStr;

		if (getMItdb().userObjs())
		  {
		    str_sprintf(predStr, " and (S.schema_name <> 'HP_DEFINITION_SCHEMA' and S.schema_name <> 'MXCS_SCHEMA' and S.schema_name <> 'SYSTEM_DEFAULTS_SCHEMA' and S.schema_name <> 'SYSTEM_SCHEMA' and S.schema_name <> 'PUBLIC_ACCESS_SCHEMA' and S.schema_name <> 'HP_ROUTINES' and S.schema_name <> 'HP_SECURITY_SCHEMA' and S.schema_name <> 'MANAGEABILITY' and left(S.schema_name, 1) <> '@' and S.current_operation <> 'VS' ) ");
		  }
		else if (getMItdb().systemObjs())
		  {
		    str_sprintf(predStr, " and (S.schema_name = 'HP_DEFINITION_SCHEMA' or S.schema_name = 'MXCS_SCHEMA' or S.schema_name = 'SYSTEM_DEFAULTS_SCHEMA' or S.schema_name = 'SYSTEM_SCHEMA' or S.schema_name = 'PUBLIC_ACCESS_SCHEMA' or S.schema_name = 'HP_ROUTINES' or S.schema_name = 'HP_SECURITY_SCHEMA' or S.schema_name = 'MANAGEABILITY' or left(S.schema_name, 1) = '@' or S.current_operation = 'VS') ");
		  }

		numOutputEntries_ = 2;
	      }
	    else
	      {
		qs = getVersionForObjectsInSchemaQuery;
		sizeOfqs = sizeof(getVersionForObjectsInSchemaQuery);

		param_[0] = getMItdb().cat_;
		param_[1] = getMItdb().cat_;
		param_[2] = getMItdb().sch_;
		param_[3] = predStr;

		switch (getMItdb().queryType_)
		  {
		  case ComTdbExeUtilGetMetadataInfo::TABLES_IN_SCHEMA_:
		    {
		      strcat(predStr, " and O.object_name_space = 'TA' and O.object_type = 'BT' ");

		      if (getMItdb().userObjs())
			{
			  strcat(predStr, " and O.object_security_class = 'UT' ");
			}
		      else if (getMItdb().systemObjs())
			{
			  strcat(predStr, " and O.object_security_class <> 'UT' ");
			}

		    }
		  break;

		  case ComTdbExeUtilGetMetadataInfo::INDEXES_IN_SCHEMA_:
		    {
		      strcat(predStr, " and O.object_name_space = 'IX' and O.object_type = 'IX' ");
		    }
		  break;

		  case ComTdbExeUtilGetMetadataInfo::VIEWS_IN_SCHEMA_:
		    {
		      strcat(predStr, " and O.object_name_space = 'TA' and O.object_type = 'VI' ");
		    }
		  break;

		  case ComTdbExeUtilGetMetadataInfo::LIBRARIES_IN_SCHEMA_:
		    {
		      strcat(predStr, " and O.object_name_space = 'LB' and O.object_type = 'LB' "); //ACH VErfiy this is stored correctly - SMDIO?
		    }
		  break;

		  case ComTdbExeUtilGetMetadataInfo::MVS_IN_SCHEMA_:
		    {
		      strcat(predStr, " and O.object_name_space = 'TA' and O.object_type = 'MV' ");
		    }
		  break;

		  case ComTdbExeUtilGetMetadataInfo::PROCEDURES_IN_SCHEMA_:
		    {
		      strcat(predStr, " and O.object_name_space = 'TA' and O.object_type = 'UR' ");
		    }
		  break;

		  case ComTdbExeUtilGetMetadataInfo::SYNONYMS_IN_SCHEMA_:
		    {
		      strcat(predStr, " and O.object_name_space = 'TA' and O.object_type = 'SY' ");
		    }
		  break;

		  case ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_SCHEMA_:
		    {
		    }
		  break;

		  default:
		    {
		      ExHandleErrors(qparent_,
				     pentry_down,
				     0,
				     getGlobals(),
				     NULL,
				     (ExeErrorCode)-4218,
				     NULL,
				     "GET"
				     );
		      step_ = HANDLE_ERROR_;
		    }
		  break;

		  } // switch

		numOutputEntries_ = 4;
	      }

	    Int32 qryArraySize = sizeOfqs / sizeof(QueryString);
	    char * gluedQuery;
	    Lng32 gluedQuerySize;
	    glueQueryFragments(qryArraySize,  qs,
			       gluedQuery, gluedQuerySize);

	    str_sprintf(queryBuf_, gluedQuery,
			param_[0], param_[1], param_[2], param_[3],
			param_[4], param_[5], param_[6], param_[7],
			param_[8], param_[9], param_[10], param_[11],
			param_[12], param_[13], param_[14]);

            NADELETEBASIC(gluedQuery, getMyHeap());
	    step_ = FETCH_ALL_ROWS_;
	  }
	break;

	case FETCH_ALL_ROWS_:
	  {
	    if (initializeInfoList(infoList_))
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    if (fetchAllRows(infoList_, queryBuf_, numOutputEntries_,
			     FALSE, retcode) < 0)
	      {
		step_ = HANDLE_ERROR_;

		break;
	      }

	    infoList_->position();

	    // find out the max length of the object name entry.
	    // This will help in formatting of output.
	    infoList_->position();
	    maxObjLen_ = 0;
	    while (NOT infoList_->atEnd())
	      {
		OutputInfo * oi = (OutputInfo*)infoList_->getCurr();
		if (strlen(oi->get(0)) > maxObjLen_)
		  maxObjLen_ = strlen(oi->get(0));

		infoList_->advance();
	      }

	    infoList_->position();

	    step_ = DISPLAY_HEADING_;
	  }
	break;

	case DISPLAY_HEADING_:
	  {
	    if (infoList_->atEnd())
	      {
		step_ = DONE_;
		break;
	      }

	    // make sure there is enough space to move header
	    if (isUpQueueFull(5))
	      {
		return WORK_CALL_AGAIN; // come back later
	      }

	    if (numOutputEntries_ == 2)
	      {
		maxObjLen_ = MAXOF(strlen("Schema"), maxObjLen_);
		str_sprintf(formatStr_, "%%%ds  %%4s", maxObjLen_);

		str_sprintf(headingBuf_, formatStr_,
			    "Schema", "OSV");
	      }
	    else
	      {
		maxObjLen_ = MAXOF(strlen("Object"), maxObjLen_);
		str_sprintf(formatStr_, "%%%ds  %%4s  %%4s  %%4s", maxObjLen_);

		str_sprintf(headingBuf_, formatStr_,
			    "Object", "OSV", "OFV", "RCBV");
	      }

	    Lng32 len = strlen(headingBuf_);
	    moveRowToUpQueue(headingBuf_);
	    str_pad(headingBuf_, len, '=');
	    headingBuf_[len] = 0;
	    moveRowToUpQueue(headingBuf_);

	    moveRowToUpQueue(" ");

	    step_ = RETURN_ROW_;
	  }
	break;

	case RETURN_ROW_:
	  {
	    if (infoList_->atEnd())
	      {
		step_ = ENABLE_CQS_;
		break;
	      }

	    if (qparent_.up->isFull())
	      return WORK_OK;

	    OutputInfo * vi = (OutputInfo*)infoList_->getCurr();

	    if (numOutputEntries_ == 2)
	      {
		str_sprintf(outputBuf_, formatStr_,
			    vi->get(0), vi->get(1));
	      }
	    else
	      {
		str_sprintf(outputBuf_, formatStr_,
			    vi->get(0), vi->get(1), vi->get(2),
			    vi->get(3));
	      }

	    short rc = 0;
	    moveRowToUpQueue(outputBuf_, 0, &rc);

	    infoList_->advance();
	  }
	break;

	case ENABLE_CQS_:
	  {
	    if (restoreCQS())
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    step_ = DONE_;
	  }
	break;

	case HANDLE_ERROR_:
	  {
	    restoreCQS();

	    retcode = handleError();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = DONE_;
	  }
	break;

	case DONE_:
	  {
	    retcode = handleDone();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = INITIAL_;

	    return WORK_OK;
	  }
	break;

	}
    }

  return 0;
}

///////////////////////////////////////////////////////////////////
ex_tcb * ExExeUtilGetHiveMetadataInfoTdb::build(ex_globals * glob)
{
  ExExeUtilGetHiveMetadataInfoTcb * exe_util_tcb;

  exe_util_tcb =
    new(glob->getSpace()) ExExeUtilGetHiveMetadataInfoTcb(*this, glob);
  
  exe_util_tcb->registerSubtasks();

  return (exe_util_tcb);
}

////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilGetMetadataInfoTcb
///////////////////////////////////////////////////////////////
ExExeUtilGetHiveMetadataInfoTcb::ExExeUtilGetHiveMetadataInfoTcb(
     const ComTdbExeUtilGetHiveMetadataInfo & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilGetMetadataInfoTcb( exe_util_tdb, glob)
{
  queryBuf_ = new(glob->getDefaultHeap()) char[4096];
}

ExExeUtilGetHiveMetadataInfoTcb::~ExExeUtilGetHiveMetadataInfoTcb()
{
}

//////////////////////////////////////////////////////
// work() for ExExeUtilGetHiveMetadataInfoTcb
//////////////////////////////////////////////////////
short ExExeUtilGetHiveMetadataInfoTcb::fetchAllHiveRows(Queue * &infoList, 
							Lng32 numOutputEntries,
							short &rc)
{
  Lng32 cliRC = 0;
  rc = 0;

  char buf[2000];
  char wherePred[400];
  if ((getMItdb().queryType() == ComTdbExeUtilGetMetadataInfo::TABLES_IN_SCHEMA_) ||
      (getMItdb().queryType() == ComTdbExeUtilGetMetadataInfo::TABLES_IN_CATALOG_))
    strcpy(wherePred, " where hive_table_type = 'MANAGED_TABLE' or hive_table_type = 'EXTERNAL_TABLE' ");
  else if ((getMItdb().queryType() == ComTdbExeUtilGetMetadataInfo::VIEWS_IN_SCHEMA_) ||
           (getMItdb().queryType() == ComTdbExeUtilGetMetadataInfo::VIEWS_IN_CATALOG_))
    strcpy(wherePred, " where hive_table_type = 'VIRTUAL_VIEW' ");
  else if ((getMItdb().queryType() == ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_SCHEMA_) ||
           (getMItdb().queryType() == ComTdbExeUtilGetMetadataInfo::OBJECTS_IN_CATALOG_) ||
           (getMItdb().queryType() == ComTdbExeUtilGetMetadataInfo::SCHEMAS_IN_CATALOG_))
    strcpy(wherePred, " ");

  if (getMItdb().queryType() == ComTdbExeUtilGetMetadataInfo::SCHEMAS_IN_CATALOG_)
    str_sprintf(buf, "select trim(schema_name) from table(hivemd(schemas)) group by 1 order by 1");
  else if (getMItdb().getSch())
    str_sprintf(buf, "select rtrim(table_name) from table(hivemd(tables, \"%s\")) %s order by 1", 
                getMItdb().getSch(),
                wherePred);
  else
    str_sprintf(buf, "select trim(schema_name) || '.' || trim(table_name) from table(hivemd(tables)) %s order by 1", 
                wherePred);
    
  cliRC = fetchAllRows(infoList, buf, 1, TRUE, rc, FALSE);

  return cliRC;
}
  
short ExExeUtilGetHiveMetadataInfoTcb::work()
{
  short retcode = 0;
  Lng32 cliRC = 0;
  ex_expr::exp_return_type exprRetCode = ex_expr::EXPR_OK;

  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;

  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;

  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getStatement()->getContext();

  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
	    step_ = FETCH_ALL_ROWS_;
	  }
	  break;

	case FETCH_ALL_ROWS_:
	  {
	    if (initializeInfoList(infoList_))
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }
	    
	    short rc = 0;
	    retcode = fetchAllHiveRows(infoList_, 1, rc);
	    if (retcode < 0)
	      {
                cliInterface()->retrieveSQLDiagnostics(getDiagsArea());
		step_ = HANDLE_ERROR_;
		break;
	      }

	    infoList_->position();

	    headingReturned_ = FALSE;

	    step_ = RETURN_ROW_;
	  }
	  break;

	case RETURN_ROW_:
	  {
	    if (infoList_->atEnd())
	      {
		step_ = DONE_;
		break;
	      }

	    if (qparent_.up->isFull())
	      return WORK_OK;

	    OutputInfo * vi = (OutputInfo*)infoList_->getCurr();
	    char * ptr = vi->get(0);
	    short len = *(short*)ptr;
 
	    ex_expr::exp_return_type exprRetCode = 
              exprRetCode = evalScanExpr(ptr, len, FALSE);
	    if (exprRetCode == ex_expr::EXPR_FALSE)
	      {
		// row does not pass the scan expression,
		// move to the next row.
                infoList_->advance();
		break;
	      }
	    else if (exprRetCode == ex_expr::EXPR_ERROR)
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    if (NOT headingReturned_)
	      {
		step_ = DISPLAY_HEADING_;
		break;
	      }

	    short rc = 0;
	    ptr += SQL_VARCHAR_HDR_SIZE;
	    if (moveRowToUpQueue(ptr, len, &rc))
            {
	      return rc;
            }

	    infoList_->advance();
	  }
	  break;

	case DISPLAY_HEADING_:
	  {
	    retcode = displayHeading();
	    if (retcode == 1)
	      return WORK_OK;
	    else if (retcode < 0)
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    headingReturned_ = TRUE;

	    step_ = RETURN_ROW_;
	  }
	break;

	case HANDLE_ERROR_:
	  {
	    retcode = handleError();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = DONE_;
	  }
	break;

	case DONE_:
	  {
	    retcode = handleDone();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = INITIAL_;

	    return WORK_OK;
	  }
	break;

	} // switch
    } // while
}

////////////////////////////////////////////////////////////////////////
// Redefine virtual method allocatePstates, to be used by dynamic queue
// resizing, as well as the initial queue construction.
////////////////////////////////////////////////////////////////////////
ex_tcb_private_state * ExExeUtilGetMetadataInfoTcb::allocatePstates(
     Lng32 &numElems,      // inout, desired/actual elements
     Lng32 &pstateLength)  // out, length of one element
{
  PstateAllocator<ExExeUtilGetMetadataInfoPrivateState> pa;

  return pa.allocatePstates(this, numElems, pstateLength);
}


/////////////////////////////////////////////////////////////////////////////
// Constructor and destructor for ExeUtil_private_state
/////////////////////////////////////////////////////////////////////////////
ExExeUtilGetMetadataInfoPrivateState::ExExeUtilGetMetadataInfoPrivateState()
{
}

ExExeUtilGetMetadataInfoPrivateState::~ExExeUtilGetMetadataInfoPrivateState()
{
};



///////////////////////////////////////////////////////////////////
// class ExExeUtilShowSetTdb
///////////////////////////////////////////////////////////////
ex_tcb * ExExeUtilShowSetTdb::build(ex_globals * glob)
{
  ExExeUtilShowSetTcb * exe_util_tcb;

  exe_util_tcb = new(glob->getSpace()) ExExeUtilShowSetTcb(*this, glob);

  exe_util_tcb->registerSubtasks();

  return (exe_util_tcb);
}

ExExeUtilShowSetTcb::ExExeUtilShowSetTcb(const ComTdbExeUtilShowSet & exe_util_tdb,
					 ex_globals * glob)
     : ExExeUtilTcb(exe_util_tdb, NULL, glob),
       step_(EMPTY_)
{
}

short ExExeUtilShowSetTcb::work()
{
  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;

  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();

  ContextCli *currContext =
      getGlobals()->castToExExeStmtGlobals()->castToExMasterStmtGlobals()->
        getStatement()->getContext();

  SessionDefaults * sd = currContext->getSessionDefaults();

  while (1)
    {
      switch (step_)
	{
	case EMPTY_:
	  {
	    sd->position();

	    step_ = RETURN_HEADER_;
	  }
	break;

	case RETURN_HEADER_:
	  {
	    // if no room in up queue for 2 display rows,
	    // won't be able to return data/status.
	    // Come back later.
	    if ((qparent_.up->getSize() - qparent_.up->getLength()) < 3)
	      return -1;

	    moveRowToUpQueue("  ");
	    moveRowToUpQueue("Current SESSION DEFAULTs");

	    step_ = RETURNING_DEFAULT_;
	  }
	break;

	case RETURNING_DEFAULT_:
	  {
	    // if no room in up queue, won't be able to return data/status.
	    // Come back later.
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    char * attributeString = NULL;
	    char * attributeValue  = NULL;
	    Lng32 isCQD;
	    Lng32 fromDefaultsTable;
	    Lng32 isSSD;
	    Lng32 isExternalized = 0;
	    Lng32 eof = 0;
	    while ((NOT eof) && (NOT isExternalized))
	      {
		eof = sd->getNextSessionDefault(attributeString,
						attributeValue,
						isCQD,
						fromDefaultsTable,
						isSSD,
						isExternalized);

		if (ssTdb().getType() == ComTdbExeUtilShowSet::ALL_)
		  isExternalized = TRUE;
	      }

	    if (eof)
	      {
		step_ = DONE_;
		break;
	      }

	    char formattedStr[2000];
	    strcpy(formattedStr, "  ");
	    byte_str_cpy(&formattedStr[2], 28, attributeString,
			 strlen(attributeString),' ');
	    formattedStr[2+28] = 0;

	    if (attributeValue)
	      strcat(formattedStr, attributeValue);

	    moveRowToUpQueue(formattedStr);
	  }
	break;

	case DONE_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    // all ok. Return EOF.
	    ex_queue_entry * up_entry = qparent_.up->getTailEntry();

	    up_entry->upState.parentIndex =
	      pentry_down->downState.parentIndex;

	    up_entry->upState.setMatchNo(0);
	    up_entry->upState.status = ex_queue::Q_NO_DATA;

	    // insert into parent
	    qparent_.up->insert();

	    step_ = EMPTY_;

	    qparent_.down->removeHead();

	    return WORK_OK;
	  }
	  break;

	} // switch
    }

  return 0;
}

//LCOV_EXCL_START

///////////////////////////////////////////////////////////////////
ex_tcb * ExExeUtilGetUIDTdb::build(ex_globals * glob)
{
  ex_tcb * exe_util_tcb;

  exe_util_tcb = new(glob->getSpace()) ExExeUtilGetUIDTcb(*this, glob);

  exe_util_tcb->registerSubtasks();

  return (exe_util_tcb);
}

////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilGetUIDTcb
///////////////////////////////////////////////////////////////
ExExeUtilGetUIDTcb::ExExeUtilGetUIDTcb(
     const ComTdbExeUtilGetUID & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilTcb( exe_util_tdb, NULL, glob)
{
  // Allocate the private state in each entry of the down queue
  qparent_.down->allocatePstate(this);

  step_ = INITIAL_;

}

ExExeUtilGetUIDTcb::~ExExeUtilGetUIDTcb()
{
}

//////////////////////////////////////////////////////
// work() for ExExeUtilGetUIDTcb
//////////////////////////////////////////////////////
short ExExeUtilGetUIDTcb::work()
{
  //  short rc = 0;
  Lng32 cliRC = 0;

  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;

  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;

  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getStatement()->getContext();

  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
	    step_ = RETURN_UID_;
	  }
	break;

	case RETURN_UID_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    moveRowToUpQueue((const char*)&(getUIDTdb().uid_),
			     sizeof(getUIDTdb().uid_),
			     NULL, FALSE);

	    step_ = DONE_;
	  }
	break;

	case ERROR_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    ExHandleErrors(qparent_,
			   pentry_down,
			   0,
			   getGlobals(),
			   NULL,
			   (ExeErrorCode)cliRC,
			   NULL,
			   NULL
			   );
	    step_ = DONE_;
	  }
	break;

	case DONE_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    // Return EOF.
	    ex_queue_entry * up_entry = qparent_.up->getTailEntry();

	    up_entry->upState.parentIndex =
	      pentry_down->downState.parentIndex;

	    up_entry->upState.setMatchNo(0);
	    up_entry->upState.status = ex_queue::Q_NO_DATA;

	    // insert into parent
	    qparent_.up->insert();

	    qparent_.down->removeHead();

	    step_ = INITIAL_;
	    return WORK_OK;
	  }

	break;

	default:
	  break;

	}

    }

  return 0;
}


////////////////////////////////////////////////////////////////////////
// Redefine virtual method allocatePstates, to be used by dynamic queue
// resizing, as well as the initial queue construction.
////////////////////////////////////////////////////////////////////////
ex_tcb_private_state * ExExeUtilGetUIDTcb::allocatePstates(
     Lng32 &numElems,      // inout, desired/actual elements
     Lng32 &pstateLength)  // out, length of one element
{
  PstateAllocator<ExExeUtilGetUIDPrivateState> pa;

  return pa.allocatePstates(this, numElems, pstateLength);
}

/////////////////////////////////////////////////////////////////////////////
// Constructor and destructor for ExeUtil_private_state
/////////////////////////////////////////////////////////////////////////////
ExExeUtilGetUIDPrivateState::ExExeUtilGetUIDPrivateState()
{
}

ExExeUtilGetUIDPrivateState::~ExExeUtilGetUIDPrivateState()
{
};

///////////////////////////////////////////////////////////////////
ex_tcb * ExExeUtilGetQIDTdb::build(ex_globals * glob)
{
  ex_tcb * exe_util_tcb;

  exe_util_tcb = new(glob->getSpace()) ExExeUtilGetQIDTcb(*this, glob);

  exe_util_tcb->registerSubtasks();

  return (exe_util_tcb);
}

////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilGetQIDTcb
///////////////////////////////////////////////////////////////
ExExeUtilGetQIDTcb::ExExeUtilGetQIDTcb(
     const ComTdbExeUtilGetQID & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilTcb( exe_util_tdb, NULL, glob)
{
  // Allocate the private state in each entry of the down queue
  qparent_.down->allocatePstate(this);

  step_ = INITIAL_;

}

ExExeUtilGetQIDTcb::~ExExeUtilGetQIDTcb()
{
}

//////////////////////////////////////////////////////
// work() for ExExeUtilGetQIDTcb
//////////////////////////////////////////////////////
short ExExeUtilGetQIDTcb::work()
{
  short retcode = 0;
  Lng32 cliRC = 0;

  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;

  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;

  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getStatement()->getContext();

  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
	    step_ = RETURN_QID_;
	  }
	break;

	case RETURN_QID_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

            /* get statement from context */
            SQLMODULE_ID module;
            init_SQLMODULE_ID(&module);

            SQLSTMT_ID stmtId;
            memset (&stmtId, 0, sizeof(SQLSTMT_ID));

            // Allocate a SQL statement
            init_SQLSTMT_ID(&stmtId, SQLCLI_CURRENT_VERSION, stmt_name, 
                            &module, getQIDTdb().getStmtName(), NULL, NULL, 
                            strlen(getQIDTdb().getStmtName()));

            Statement * stmt = currContext->getStatement(&stmtId);
            
            /* stmt must exist */
            if (!stmt)
              {
                ExHandleErrors(qparent_,
                               pentry_down,
                               0,
                               getGlobals(),
                               NULL,
                               (ExeErrorCode)-CLI_STMT_NOT_EXISTS,
                               NULL,
                               NULL
                               );
                step_ = ERROR_;
                break;
              }
            
	    moveRowToUpQueue(stmt->getUniqueStmtId());

	    step_ = DONE_;
	  }
	break;

	case ERROR_:
	  {
	    retcode = handleError();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = DONE_;
	  }
	break;

	case DONE_:
	  {
	    retcode = handleDone();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = INITIAL_;
	    return WORK_OK;
	  }

	break;

	default:
	  break;

	}

    }

  return 0;
}


////////////////////////////////////////////////////////////////////////
// Redefine virtual method allocatePstates, to be used by dynamic queue
// resizing, as well as the initial queue construction.
////////////////////////////////////////////////////////////////////////
ex_tcb_private_state * ExExeUtilGetQIDTcb::allocatePstates(
     Lng32 &numElems,      // inout, desired/actual elements
     Lng32 &pstateLength)  // out, length of one element
{
  PstateAllocator<ExExeUtilGetQIDPrivateState> pa;

  return pa.allocatePstates(this, numElems, pstateLength);
}

/////////////////////////////////////////////////////////////////////////////
// Constructor and destructor for ExeUtil_private_state
/////////////////////////////////////////////////////////////////////////////
ExExeUtilGetQIDPrivateState::ExExeUtilGetQIDPrivateState()
{
}

ExExeUtilGetQIDPrivateState::~ExExeUtilGetQIDPrivateState()
{
};

///////////////////////////////////////////////////////////////////
ex_tcb * ExExeUtilGetErrorInfoTdb::build(ex_globals * glob)
{
  ExExeUtilGetErrorInfoTcb * exe_util_tcb;

  exe_util_tcb =
    new(glob->getSpace()) ExExeUtilGetErrorInfoTcb(*this, glob);

  exe_util_tcb->registerSubtasks();

  return (exe_util_tcb);
}

////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilGetErrorInfoTcb
///////////////////////////////////////////////////////////////
ExExeUtilGetErrorInfoTcb::ExExeUtilGetErrorInfoTcb(
     const ComTdbExeUtilGetErrorInfo & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilTcb( exe_util_tdb, NULL, glob)
{
  // Allocate the private state in each entry of the down queue
  qparent_.down->allocatePstate(this);

  step_ = INITIAL_;

  // buffer where output will be formatted
  outputBuf_ = new(glob->getDefaultHeap()) char[4096];
}

//////////////////////////////////////////////////////
// work() for ExExeUtilGetErrorInfoTcb
//////////////////////////////////////////////////////
short ExExeUtilGetErrorInfoTcb::work()
{
  short retcode = 0;
  Lng32 cliRC = 0;
  ex_expr::exp_return_type exprRetCode = ex_expr::EXPR_OK;

  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;

  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;

  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getStatement()->getContext();

  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
	    step_ = RETURN_TEXT_;
	  }
	break;

	case RETURN_TEXT_:
	  {
	    if ((qparent_.up->getSize() - qparent_.up->getLength()) < 10)
	      return WORK_OK;

	    Lng32 warnNum = ABS(geiTdb().errNum_);
	    Lng32 errNum = -geiTdb().errNum_;
	    
	    char sqlstateErr[10];
	    char sqlstateWarn[10];

	    ComSQLSTATE(errNum, sqlstateErr);
	    ComSQLSTATE(warnNum, sqlstateWarn);

	    NAWchar * errorMsg;
	    NABoolean msgNotFound = 
	      GetErrorMessage(errNum, errorMsg, ERROR_TEXT);

	    Lng32 bufSize = 2 * ErrorMessage::MSG_BUF_SIZE + 16;
	    char * isoErrorMsg = new(getGlobals()->getDefaultHeap()) 
	      char[bufSize];

	    moveRowToUpQueue("");

	    if ((! msgNotFound) || (errNum == 0))
	      {	      

		UnicodeStringToLocale
		  (CharInfo::ISO88591,
		   errorMsg, NAWstrlen(errorMsg), isoErrorMsg, bufSize);

		   str_sprintf(outputBuf_, "*** SQLSTATE (Err): %s SQLSTATE (Warn): %s", 
			    sqlstateErr, sqlstateWarn);
		moveRowToUpQueue(outputBuf_);

		str_sprintf(outputBuf_, "%s", isoErrorMsg);
		moveRowToUpQueue(outputBuf_);
	      }
	    else
	      {
		str_sprintf(outputBuf_, "*** WARNING[%d]",
			    warnNum);
		moveRowToUpQueue(outputBuf_);

		str_sprintf(outputBuf_, "*** ERROR[16001] The error number %d is not used in SQL.",
			    warnNum);
		moveRowToUpQueue(outputBuf_);
	      }

	    NADELETEBASIC(isoErrorMsg, getGlobals()->getDefaultHeap());

	    step_ = DONE_;
	  }
	  break;

	case ERROR_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    ExHandleErrors(qparent_,
			   pentry_down,
			   0,
			   getGlobals(),
			   NULL,
			   (ExeErrorCode)cliRC,
			   NULL,
			   NULL
			   );
	    step_ = DONE_;
	  }
	break;

	case DONE_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    // Return EOF.
	    ex_queue_entry * up_entry = qparent_.up->getTailEntry();

	    up_entry->upState.parentIndex =
	      pentry_down->downState.parentIndex;

	    up_entry->upState.setMatchNo(0);
	    up_entry->upState.status = ex_queue::Q_NO_DATA;

	    // insert into parent
	    qparent_.up->insert();

	    qparent_.down->removeHead();

	    step_ = INITIAL_;
	    return WORK_OK;
	  } // case
	  break;
	} // switch
    } // while
}

////////////////////////////////////////////////////////////////////////
// Redefine virtual method allocatePstates, to be used by dynamic queue
// resizing, as well as the initial queue construction.
////////////////////////////////////////////////////////////////////////
ex_tcb_private_state * ExExeUtilGetErrorInfoTcb::allocatePstates(
     Lng32 &numElems,      // inout, desired/actual elements
     Lng32 &pstateLength)  // out, length of one element
{
  PstateAllocator<ExExeUtilGetErrorInfoPrivateState> pa;

  return pa.allocatePstates(this, numElems, pstateLength);
}


/////////////////////////////////////////////////////////////////////////////
// Constructor and destructor for ExeUtil_private_state
/////////////////////////////////////////////////////////////////////////////
ExExeUtilGetErrorInfoPrivateState::ExExeUtilGetErrorInfoPrivateState()
{
}

ExExeUtilGetErrorInfoPrivateState::~ExExeUtilGetErrorInfoPrivateState()
{
}

///////////////////////////////////////////////////////////////////
// class ExExeUtilLobShowddlTdb
///////////////////////////////////////////////////////////////
ex_tcb * ExExeUtilLobShowddlTdb::build(ex_globals * glob)
{
  ExExeUtilLobShowddlTcb * exe_util_tcb;

  exe_util_tcb = new(glob->getSpace()) ExExeUtilLobShowddlTcb(*this, glob);

  exe_util_tcb->registerSubtasks();

  return (exe_util_tcb);
}

ExExeUtilLobShowddlTcb::ExExeUtilLobShowddlTcb
(
 const ComTdbExeUtilLobShowddl & exe_util_tdb,
 ex_globals * glob)
  : ExExeUtilTcb(exe_util_tdb, NULL, glob),
    step_(INITIAL_)
{
  strcpy(lobMDNameBuf_,"");
  lobMDNameLen_=0;
  lobMDName_ = NULL;
  
  Lng32 currLobNum_ = 0;
  strcpy(sdOptionStr_,"");
}

short ExExeUtilLobShowddlTcb::fetchRows(char * query, short &rc)
{
  Lng32 cliRC = 0;

  if (initializeInfoList(infoList_)) 
    {
      step_ = HANDLE_ERROR_;
      
      return -1;
    }
  
  rc = 0;
  cliRC = 
    fetchAllRows(infoList_, query, 1, FALSE, rc);
  if (cliRC < 0) 
    {
      cliInterface()->retrieveSQLDiagnostics(getDiagsArea());

      step_ = HANDLE_ERROR_;

      return -1;
    }
  
  infoList_->position();
  
  return 0;
}

short ExExeUtilLobShowddlTcb::returnRows(short &rc)
{
  if (infoList_->atEnd())
    {
      return 100;
    }
  
  if (qparent_.up->isFull())
    {
      rc = WORK_OK;
      return -1;
    }
  
  OutputInfo * vi = (OutputInfo*)infoList_->getCurr();
  
  char * ptr = vi->get(0);
  short len = (short)(ptr ? strlen(ptr) : 0);
  
  if (moveRowToUpQueue(ptr, len, &rc))
    {
      return -1;
    }
  
  infoList_->advance();

  return 0;
}

short ExExeUtilLobShowddlTcb::work()
{
  Lng32 cliRC = 0;
  short retcode = 0;

  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;

  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;

  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);

  ContextCli *currContext =
    getGlobals()->castToExExeStmtGlobals()->castToExMasterStmtGlobals()->
    getStatement()->getContext();

  while (1)
    {
      switch (step_) 
	{
	case INITIAL_:
	  {
	    query_ = new(getGlobals()->getDefaultHeap()) char[4096];

	    lobMDNameLen_ = 1024;
	    lobMDName_ = 
	      ExpLOBoper::ExpGetLOBMDName
	      (lobTdb().schNameLen_, lobTdb().schName(), lobTdb().objectUID_,
	       lobMDNameBuf_, lobMDNameLen_);

	    strcpy(sdOptionStr_, " ");

	    switch (lobTdb().sdOptions_)
	      {
	      case 4:
		strcpy(sdOptionStr_, ", detail");
		break;

	      case 8:
		strcpy(sdOptionStr_, ", brief");
		break;

	      case 32:
		strcpy(sdOptionStr_, ", external");
		break;

	      case 64:
		strcpy(sdOptionStr_, ", internal");
		break;
	      }

	    step_ = FETCH_TABLE_SHOWDDL_;
	  }
	  break;

	case FETCH_TABLE_SHOWDDL_:
	  {
	    str_sprintf(query_, "showddl %s %s", 
			lobTdb().getTableName(),
			sdOptionStr_);

	    if (fetchRows(query_, retcode))
	      {
		break;
	      }

	    step_ = RETURN_TABLE_SHOWDDL_;
	  }
	  break;

	case RETURN_TABLE_SHOWDDL_:
	  {
	    cliRC = returnRows(retcode);
	    if (cliRC == -1)
	      {
		return retcode;
	      }
	    else if (cliRC == 100)
	      {
		step_ = FETCH_METADATA_SHOWDDL_;
		return WORK_RESCHEDULE_AND_RETURN;
	      }
	  }
	  break;

	case FETCH_METADATA_SHOWDDL_:
	  {
	    if ((qparent_.up->getSize() - qparent_.up->getLength()) < 6)
	      return WORK_OK;	//come back later

	    moveRowToUpQueue("");	    
	    moveRowToUpQueue("LOB Metadata");
	    moveRowToUpQueue("============");

	    str_sprintf(query_, "showddl table(ghost table %s) %s", 
			lobMDName_,
			sdOptionStr_);

	    // set parserflags to allow ghost table
	    currContext->setSqlParserFlags(0x1);

	    cliRC = fetchRows(query_, retcode);

	    currContext->resetSqlParserFlags(0x1);

	    if (cliRC < 0)
	      {
		break;
	      }

	    step_ = RETURN_METADATA_SHOWDDL_;
	  }
	  break;

	case RETURN_METADATA_SHOWDDL_:
	  {
	    cliRC = returnRows(retcode);
	    if (cliRC == -1)
	      {
		return retcode;
	      }
	    else if (cliRC == 100)
	      {
		currLobNum_ = 1;
		step_ = RETURN_LOB_NAME_;
		return WORK_RESCHEDULE_AND_RETURN;
	      }
	  }
	  break;

	case RETURN_LOB_NAME_:
	  {
	    if ((qparent_.up->getSize() - qparent_.up->getLength()) < 15)
	      return WORK_OK;	//come back later

	    if (currLobNum_ > lobTdb().numLOBs())
	      {
		step_ = DONE_;
		break;
	      }

	    moveRowToUpQueue(" ");
	    moveRowToUpQueue("************************************************");
	    str_sprintf(query_, "LobNum: %d", currLobNum_);
	    moveRowToUpQueue(query_);
	    moveRowToUpQueue(" ");

	    moveRowToUpQueue("Data Storage");
	    moveRowToUpQueue("============");
	    moveRowToUpQueue(" ");

	    char tgtLobNameBuf[100];
	    char * tgtLobName = 
	      ExpLOBoper::ExpGetLOBname
	      (lobTdb().objectUID_, lobTdb().getLOBnum(currLobNum_), 
	       tgtLobNameBuf, 100);

	    if (lobTdb().getIsExternalLobCol(currLobNum_))
              str_sprintf(query_, "<External HDFS location>");
            else 
              str_sprintf(query_, "Location: %s", 
			lobTdb().getLOBloc(currLobNum_));
	    moveRowToUpQueue(query_);

            if (lobTdb().getIsExternalLobCol(currLobNum_))
              str_sprintf(query_, "<External HDFS file>");
            else 
              str_sprintf(query_, "DataFile: %s", tgtLobName);
	    moveRowToUpQueue(query_);

	    step_ = FETCH_LOB_DESC_HANDLE_SHOWDDL_;

	    return WORK_RESCHEDULE_AND_RETURN;
	  }
	  break;

	case FETCH_LOB_DESC_HANDLE_SHOWDDL_:
	  {
	    if ((qparent_.up->getSize() - qparent_.up->getLength()) < 6)
	      return WORK_OK;	//come back later

	    moveRowToUpQueue("");	    
	    moveRowToUpQueue("LOB Descriptor Handle");
	    moveRowToUpQueue("=====================");

	    char lobDescNameBuf[1024];
	    Lng32 lobDescNameLen = 1024;
	    char * lobDescName = 
	      ExpLOBoper::ExpGetLOBDescHandleName
	      (lobTdb().schNameLen_, lobTdb().schName(), 
	       lobTdb().objectUID_,
	       lobTdb().getLOBnum(currLobNum_), 
	       lobDescNameBuf, lobDescNameLen);
	    str_sprintf(query_, "showddl table(ghost table %s) %s", 
			lobDescName,
			sdOptionStr_);

	    // set parserflags to allow ghost table
	    currContext->setSqlParserFlags(0x1);

	    cliRC = fetchRows(query_, retcode);

	    currContext->resetSqlParserFlags(0x1);

	    if (cliRC < 0)
	      {
		break;
	      }

	    step_ = RETURN_LOB_DESC_HANDLE_SHOWDDL_;
	  }
	  break;

	case RETURN_LOB_DESC_HANDLE_SHOWDDL_:
	  {
	    cliRC = returnRows(retcode);
	    if (cliRC == -1)
	      {
		return retcode;
	      }
	    else if (cliRC == 100)
	      {
		step_ = FETCH_LOB_DESC_CHUNKS_SHOWDDL_;
		return WORK_RESCHEDULE_AND_RETURN;
	      }
	  }
	  break;

	case FETCH_LOB_DESC_CHUNKS_SHOWDDL_:
	  {
	    if ((qparent_.up->getSize() - qparent_.up->getLength()) < 6)
	      return WORK_OK;	//come back later

	    moveRowToUpQueue("");	    
	    moveRowToUpQueue("LOB Descriptor Chunks");
	    moveRowToUpQueue("=====================");

	    char lobDescNameBuf[1024];
	    Lng32 lobDescNameLen = 1024;
	    char * lobDescName = 
	      ExpLOBoper::ExpGetLOBDescChunksName
	      (lobTdb().schNameLen_, lobTdb().schName(), 
	       lobTdb().objectUID_,
	       lobTdb().getLOBnum(currLobNum_), 
	       lobDescNameBuf, lobDescNameLen);
	    str_sprintf(query_, "showddl table(ghost table %s) %s", 
			lobDescName,
			sdOptionStr_);

	    // set parserflags to allow ghost table
	    currContext->setSqlParserFlags(0x1);

	    cliRC = fetchRows(query_, retcode);

	    currContext->resetSqlParserFlags(0x1);

	    if (cliRC < 0)
	      {
		break;
	      }

	    step_ = RETURN_LOB_DESC_CHUNKS_SHOWDDL_;
	  }
	  break;

	case RETURN_LOB_DESC_CHUNKS_SHOWDDL_:
	  {
	    cliRC = returnRows(retcode);
	    if (cliRC == -1)
	      {
		return retcode;
	      }
	    else if (cliRC == 100)
	      {
		currLobNum_++;
		step_ = RETURN_LOB_NAME_;
		return WORK_RESCHEDULE_AND_RETURN;
	      }
	  }
	  break;

	case HANDLE_ERROR_:
	  {
	    retcode = handleError();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = DONE_;
	  }
	  break;

	case DONE_:
	  {
	    retcode = handleDone();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = INITIAL_;
	    return WORK_OK;
	  }
	  break;

	} // switch
    }

  return 0;
}

///////////////////////////////////////////////////////////////////
ex_tcb * ExExeUtilHiveMDaccessTdb::build(ex_globals * glob)
{
  ExExeUtilHiveMDaccessTcb * exe_util_tcb;

  exe_util_tcb =
    new(glob->getSpace()) ExExeUtilHiveMDaccessTcb(*this, glob);

  exe_util_tcb->registerSubtasks();

  return (exe_util_tcb);
}

////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilHiveMDaccessTcb
///////////////////////////////////////////////////////////////
ExExeUtilHiveMDaccessTcb::ExExeUtilHiveMDaccessTcb(
     const ComTdbExeUtilHiveMDaccess & exe_util_tdb,
     ex_globals * glob)
  : ExExeUtilTcb( exe_util_tdb, NULL, glob),
    hiveMD_(NULL),
    currColDesc_(NULL),
    currKeyDesc_(NULL),
    schNames_(getHeap()),
    tblNames_(getHeap()),
    currSchNum_(0),
    currColNum_(0)
{
  step_ = INITIAL_;

  mdRow_ = new(getHeap()) char[exe_util_tdb.outputRowlen_];
}

ExExeUtilHiveMDaccessTcb::~ExExeUtilHiveMDaccessTcb()
{

}

// should move this method to common dir.
Lng32 ExExeUtilHiveMDaccessTcb::getFSTypeFromHiveColType(const char* hiveType)
{
  Lng32 fstype = -1;
  NAType * nat = NAType::getNATypeForHive(hiveType, getHeap());
  fstype = nat->getFSDatatype();
  delete nat;
  return fstype;
}

Lng32 ExExeUtilHiveMDaccessTcb::getLengthFromHiveColType(const char* hiveType)
{
  Lng32 len = -1;
  NAType * nat = NAType::getNATypeForHive(hiveType, getHeap());
  len = nat->getNominalSize();
  delete nat;
  return len;
}

short ExExeUtilHiveMDaccessTcb::work()
{
  short retcode = 0;
  Lng32 cliRC = 0;
  NABoolean retStatus = FALSE;
  ex_expr::exp_return_type exprRetCode = ex_expr::EXPR_OK;

  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;

  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;

  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getStatement()->getContext();
  
  ComDiagsArea * diags = getDiagsArea();

  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
	    if (hiveMD_)
	      NADELETEBASIC(hiveMD_, getHeap());

            hiveMD_ = new (getHeap()) HiveMetaData();

            if (hiveMDtdb().getCatalog())
              strcpy(hiveCat_, hiveMDtdb().getCatalog());
 
            retStatus = hiveMD_->init();
            if (!retStatus)
              {
                *diags << DgSqlCode(-1190)
                       << DgString0(hiveMD_->getErrMethodName())
                       << DgString1(hiveMD_->getErrCodeStr())
                       << DgString2(hiveMD_->getErrDetail())
                       << DgInt0(hiveMD_->getErrCode());
                step_ = HANDLE_ERROR_;
                break;
              }

            step_ = SETUP_SCHEMAS_;
	  }
	  break;

        case SETUP_SCHEMAS_:
          {
	    if ((hiveMDtdb().mdType_ == ComTdbExeUtilHiveMDaccess::SCHEMAS_) ||
                (! hiveMDtdb().getSchema()))
              {
                HVC_RetCode retCode = hiveMD_->getClient()->
                  getAllSchemas(schNames_);
                if ((retCode != HVC_OK) && (retCode != HVC_DONE)) 
                  {
                    *diags << DgSqlCode(-1190)
                           << DgString0((char*)
                                        "HiveClient_JNI::getAllSchemas()")
                           << DgString1(hiveMD_->getClient()->
                                        getErrorText(retCode))
                           << DgInt0(retCode)
                           << DgString2(GetCliGlobals()->getJniErrorStr());
                    step_ = HANDLE_ERROR_;
                    break;
                  }
              }
            else
              {
                if ((!strcmp(hiveMDtdb().getSchema(), HIVE_SYSTEM_SCHEMA_LC)) ||
                    (!strcmp(hiveMDtdb().getSchema(), HIVE_SYSTEM_SCHEMA)))
                  {
                    strcpy(schForHive_, HIVE_DEFAULT_SCHEMA_EXE);
                  }
                else
                  {
                    strcpy(schForHive_, hiveMDtdb().getSchema());
                  }

                NAText * nat = new(getHeap()) NAText(schForHive_);
                schNames_.insert(nat);
              }

            currSchNum_ = 0;

            if (hiveMDtdb().mdType_ == ComTdbExeUtilHiveMDaccess::SCHEMAS_)
              step_ = POSITION_;
            else
              step_ = GET_ALL_TABLES_IN_SCHEMA_;
          }
          break;

        case GET_ALL_TABLES_IN_SCHEMA_:
          {
            if (currSchNum_ == schNames_.entries())
              {
                step_ = DONE_;
                break;
              }

            hiveMD_->clear();
            tblNames_.clear();

            char* currSch = (char*)schNames_[currSchNum_]->c_str();
            strcpy(schForHive_, currSch);
            if (! strcmp(schForHive_,  HIVE_DEFAULT_SCHEMA_EXE))
              strcpy(hiveSch_, HIVE_SYSTEM_SCHEMA_LC);
            else
              strcpy(hiveSch_, schForHive_);

            char* currObj = hiveMDtdb().getObject();

            if (! currObj)
              {
                HVC_RetCode retCode = hiveMD_->getClient()->
                  getAllTables(currSch, tblNames_);
                if ((retCode != HVC_OK) && (retCode != HVC_DONE)) 
                  {
                    *diags << DgSqlCode(-1190)
                           << DgString0((char*)
                                        "HiveClient_JNI::getAllTables()")
                           << DgString1(hiveMD_->getClient()->
                                        getErrorText(retCode))
                           << DgInt0(retCode)
                           << DgString2(GetCliGlobals()->getJniErrorStr());
                    step_ = HANDLE_ERROR_;
                    break;
                  }
              }
            else
              {
                NAText * nat = new(getHeap()) NAText(currObj);
                tblNames_.insert(nat);
              }

            // read info for entries specified in tblNames_
            int i = 0;
            while (i < tblNames_.entries())
              {
                hiveMD_->getTableDesc(schForHive_, tblNames_[i]->c_str());
                i++;
              }

            step_ = POSITION_;
          }
          break;

	case POSITION_:
	  {
            hive_tbl_desc * htd = NULL;
            hiveMD_->position();
            htd = hiveMD_->getNext();

	    if (hiveMDtdb().mdType_ == ComTdbExeUtilHiveMDaccess::SCHEMAS_)
	      {
                currSchNum_ = 0;
		step_ = FETCH_SCHEMA_;
	      }
	    else if (hiveMDtdb().mdType_ == ComTdbExeUtilHiveMDaccess::TABLES_)
	      {
		step_ = FETCH_TABLE_;
	      }
	    else if (hiveMDtdb().mdType_ == ComTdbExeUtilHiveMDaccess::COLUMNS_)
	      {
                currColNum_ = 0;

		if (htd)
                  {
                    currColDesc_ = htd->getColumns();
                    currPartnDesc_ = htd->getPartKey();
                  }
		else
                  {
                    currColDesc_ = NULL;
                    currPartnDesc_ = NULL;
                  }

		step_ = FETCH_COLUMN_;
	      }
	    else if (hiveMDtdb().mdType_ == ComTdbExeUtilHiveMDaccess::PKEYS_)
	      {
		if (htd)
		  currKeyDesc_ = htd->getBucketingKeys();
		else
		  currKeyDesc_ = NULL;

		step_ = FETCH_PKEY_;
	      }
	    else
	      {
		step_ = DONE_;
		break;
	      }
	  }
	  break;

	case FETCH_SCHEMA_: 
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    if (currSchNum_ == schNames_.entries())
	      {
		step_ = DONE_;
		break;
	      }

	    HiveMDSchemasColInfoStruct *infoCol =
              (HiveMDSchemasColInfoStruct*)mdRow_;

	    str_cpy(infoCol->catName, hiveCat_, 256, ' ');
            if (strcmp(schNames_[currSchNum_]->c_str(), HIVE_DEFAULT_SCHEMA_EXE) == 0)
              str_cpy(infoCol->schName, HIVE_SYSTEM_SCHEMA_LC, 256, ' ');
            else
              str_cpy(infoCol->schName, schNames_[currSchNum_]->c_str(), 256, ' ');
     	    
	    step_ = APPLY_PRED_;
	  }
	  break;
	  
	case FETCH_TABLE_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

            if (hiveMD_->atEnd())
              {
                step_ = ADVANCE_SCHEMA_;
                break;
              }

            HiveMDTablesColInfoStruct *s =(HiveMDTablesColInfoStruct*)mdRow_;

	    str_cpy(s->catName, hiveCat_, 256, ' ');
	    str_cpy(s->schName, hiveSch_, 256, ' ');

            struct hive_tbl_desc * htd = hiveMD_->getNext();
            str_cpy(s->tblName, htd->tblName_, 256, ' ');
            
            memset(s->fileFormat, ' ', 24);
            if (htd->getSDs())
              {
                if (htd->getSDs()->isOrcFile())
                  str_cpy(s->fileFormat, "ORC", 24, ' ');
                else if (htd->getSDs()->isTextFile())
                  str_cpy(s->fileFormat, "TEXTFILE", 24, ' ');
                else if (htd->getSDs()->isSequenceFile())
                  str_cpy(s->fileFormat, "SEQUENCE", 24, ' ');
              }

            // htd->creationTS_ is the number of seconds from epoch.
            // convert it to juliantimestamp
            s->createTime = htd->creationTS_*1000000 + COM_EPOCH_TIMESTAMP;

            s->numCols = htd->getNumOfCols();
            s->numPartCols = htd->getNumOfPartCols();
            s->numSortCols = htd->getNumOfSortCols();
            s->numBucketCols = htd->getNumOfBucketCols();

            s->fieldDelimiter = htd->getSDs()->fieldTerminator_;
            s->recordTerminator = htd->getSDs()->recordTerminator_;
            memset(s->nullFormat, ' ', 8);
            if (htd->getSDs()->nullFormat_)
              str_cpy(s->nullFormat, htd->getSDs()->nullFormat_, 8, ' ');

            str_cpy(s->location, htd->getSDs()->location_, 1024, ' ');

            str_cpy(s->hiveTableType, htd->tableType_, 128, ' ');

            str_cpy(s->hiveOwner, htd->owner_, 256, ' ');

	    step_ = APPLY_PRED_;
	  }
	  break;
	  
	case FETCH_COLUMN_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    if ((! currColDesc_) &&
                (! currPartnDesc_))
	      {
                step_ = ADVANCE_SCHEMA_;
		break;
	      }
	    
	    struct hive_tbl_desc * htd = hiveMD_->getNext();
	    struct hive_column_desc * hcd = currColDesc_;
	    struct hive_pkey_desc * hpd = currPartnDesc_;
	    
	    HiveMDColumnsColInfoStruct *infoCol =
	      (HiveMDColumnsColInfoStruct*)mdRow_;
	    
	    str_cpy(infoCol->catName, hiveCat_, 256, ' ');
	    str_cpy(infoCol->schName, hiveSch_, 256, ' ');
	    str_cpy(infoCol->tblName, htd->tblName_, 256, ' ');
            str_cpy(infoCol->colName, 
                    (hcd ? hcd->name_ : hpd->name_), 256, ' ');

            infoCol->fsDatatype = 
              getFSTypeFromHiveColType(hcd ? hcd->type_ : hpd->type_);

	    if (infoCol->fsDatatype < 0)
	      {
		char strP[300];
		sprintf(strP, "Datatype %s is not supported.", 
                        (hcd ? hcd->type_ : hpd->type_));
		*diags << DgSqlCode(-CLI_GET_METADATA_INFO_ERROR)
		       << DgString0(strP);
		
		step_ = HANDLE_ERROR_;
		break;
	      }
	    
	    const char * sdtStr = 
              Descriptor::ansiTypeStrFromFSType(infoCol->fsDatatype);
	    str_cpy(infoCol->sqlDatatype, sdtStr, 32, ' ');

            str_cpy(infoCol->hiveDatatype, (hcd ? hcd->type_ : hpd->type_), 
                    32, ' ');

	    infoCol->colSize = 
              getLengthFromHiveColType(hcd ? hcd->type_ : hpd->type_);
	    infoCol->colScale = 0;

	    // only iso charset
	    if ((infoCol->fsDatatype == REC_BYTE_F_ASCII) ||
		(infoCol->fsDatatype == REC_BYTE_V_ASCII))
	      str_cpy(infoCol->charSet, "ISO88591", 40, ' ');
	    else
	      str_pad(infoCol->charSet, 40, ' ');

	    infoCol->colPrecision = 0;
	    infoCol->nullable = 1;

	    infoCol->dtCode = 0;
	    infoCol->dtStartField = 0;
	    infoCol->dtEndField = 0;
	    str_pad(infoCol->dtQualifier, 28, ' ');

	    if (infoCol->fsDatatype == REC_DATETIME)
	    {
              if(infoCol->colSize > 10) {
		infoCol->dtCode = SQLDTCODE_TIMESTAMP;
		infoCol->colScale = 6;
		str_cpy(infoCol->dtQualifier, "(6)", 28, ' ');
		infoCol->dtStartField = 1;
		infoCol->dtEndField = 6;
              }
              else
              {
		infoCol->dtCode = SQLDTCODE_DATE;
		infoCol->colScale = 0;
	        str_pad(infoCol->dtQualifier, 28, ' ');
		infoCol->dtStartField = 1;
		infoCol->dtEndField = 3;
              }
	    }

	    // no default value
	    str_cpy(infoCol->defVal, " ", 240, ' ');

	    infoCol->colNum = currColNum_++;
            infoCol->partColNum = hcd ? -1 : hpd->idx_;
            infoCol->bucketColNum = 
              htd->getBucketColNum(hcd ? hcd->name_ : hpd->name_);
            infoCol->sortColNum = 
              htd->getSortColNum(hcd ? hcd->name_ : hpd->name_);

	    step_ = APPLY_PRED_;
	  }
	  break;

	case FETCH_PKEY_:  // does not work with JNI
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    if (! currKeyDesc_)
	      {
                step_ = ADVANCE_SCHEMA_;
		break;
	      }

	    struct hive_tbl_desc * htd = hiveMD_->getNext();
	    struct hive_bkey_desc * hbd = currKeyDesc_;

	    HiveMDPKeysColInfoStruct *infoCol =(HiveMDPKeysColInfoStruct*)mdRow_;

	    str_cpy(infoCol->catName, hiveCat_, 256, ' ');
	    str_cpy(infoCol->schName, hiveSch_, 256, ' ');
	    str_cpy(infoCol->tblName, htd->tblName_, 256, ' ');
	    str_cpy(infoCol->colName, hbd->name_, 256, ' ');
	    infoCol->ordPos = hbd->idx_;
     	    
	    step_ = APPLY_PRED_;
	  }
	  break;
	  
	  case APPLY_PRED_:
	  {
	    if (!hiveMDtdb().scanExpr_)
	      {
		step_ = RETURN_ROW_;
		break;
	      }

	    ex_expr::exp_return_type exprRetCode = ex_expr::EXPR_OK;

	    workAtp_->getTupp(hiveMDtdb().workAtpIndex())
	      .setDataPointer(mdRow_);

	    exprRetCode =
	      hiveMDtdb().scanExpr_->eval(pentry_down->getAtp(), workAtp_);
	    
	    if (exprRetCode == ex_expr::EXPR_ERROR)
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

	    if (exprRetCode == ex_expr::EXPR_TRUE)
	      {
		step_ = RETURN_ROW_;
		break;
	      }

	    step_ = ADVANCE_ROW_;
	  }
	  break;

	case RETURN_ROW_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    short rc = 0;
	    if (moveRowToUpQueue(mdRow_, hiveMDtdb().outputRowlen(), &rc, FALSE))
	      return rc;
	    
	    step_ = ADVANCE_ROW_;
	  }
	  break;

	case ADVANCE_ROW_:
	  {
	    if (hiveMDtdb().mdType_ == ComTdbExeUtilHiveMDaccess::SCHEMAS_)
	      {
                // move to the next schema
                currSchNum_++;

		step_ = FETCH_SCHEMA_;
	      }
	    else if (hiveMDtdb().mdType_ == ComTdbExeUtilHiveMDaccess::TABLES_)
	      {
                // move to the next table
                hiveMD_->advance();

		step_ = FETCH_TABLE_;
	      }

            // next two else blocks do not work with JNI
	    else if (hiveMDtdb().mdType_ == ComTdbExeUtilHiveMDaccess::COLUMNS_)
	      {
		if (currColDesc_)
		  currColDesc_ = currColDesc_->next_;
                else if (currPartnDesc_)
                  currPartnDesc_ = currPartnDesc_->next_;

		if ((! currColDesc_) &&
                    (! currPartnDesc_))
		  {
                    currColNum_ = 0;

		    // move to the next table
		    hiveMD_->advance();
		    
		    if (! hiveMD_->atEnd())
                      {
                        currColDesc_ = hiveMD_->getNext()->getColumns();
                        currPartnDesc_ = hiveMD_->getNext()->getPartKey();
                      }
		  }

		step_ = FETCH_COLUMN_;
	      }
	    else if (hiveMDtdb().mdType_ == ComTdbExeUtilHiveMDaccess::PKEYS_)
	      {
		if (currKeyDesc_)
		  currKeyDesc_ = currKeyDesc_->next_;
		
		if (! currKeyDesc_)
		  {
		    // move to the next table
		    hiveMD_->advance();
		    
		    if (! hiveMD_->atEnd())
		      currKeyDesc_ = hiveMD_->getNext()->getBucketingKeys();
		  }

		step_ = FETCH_PKEY_;
	      }
	    else
	      step_ = HANDLE_ERROR_;
	  }
	  break;

        case ADVANCE_SCHEMA_:
          {
            currSchNum_++;
            step_ = GET_ALL_TABLES_IN_SCHEMA_;
          }
          break;
          
	case HANDLE_ERROR_:
	  {
	    retcode = handleError();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = DONE_;
	  }
	break;

	case DONE_:
	  {
	    retcode = handleDone();
	    if (retcode == 1)
	      return WORK_OK;

	    step_ = INITIAL_;

	    return WORK_OK;
	  }
	break;

	} // switch
    } // while
}

////////////////////////////////////////////////////////////////////////
// Redefine virtual method allocatePstates, to be used by dynamic queue
// resizing, as well as the initial queue construction.
////////////////////////////////////////////////////////////////////////
ex_tcb_private_state * ExExeUtilHiveMDaccessTcb::allocatePstates(
     Lng32 &numElems,      // inout, desired/actual elements
     Lng32 &pstateLength)  // out, length of one element
{
  PstateAllocator<ExExeUtilHiveMDaccessPrivateState> pa;

  return pa.allocatePstates(this, numElems, pstateLength);
}


/////////////////////////////////////////////////////////////////////////////
// Constructor and destructor for ExeUtil_private_state
/////////////////////////////////////////////////////////////////////////////
ExExeUtilHiveMDaccessPrivateState::ExExeUtilHiveMDaccessPrivateState()
{
}

ExExeUtilHiveMDaccessPrivateState::~ExExeUtilHiveMDaccessPrivateState()
{
};

///////////////////////////////////////////////////////////////////
ex_tcb * ExExeUtilRegionStatsTdb::build(ex_globals * glob)
{
  ExExeUtilRegionStatsTcb * exe_util_tcb;

  if (displayFormat())
    exe_util_tcb = new(glob->getSpace()) ExExeUtilRegionStatsFormatTcb(*this, glob);
  else if (clusterView())
    exe_util_tcb = new(glob->getSpace()) ExExeUtilClusterStatsTcb(*this, glob);
  else
    exe_util_tcb = new(glob->getSpace()) ExExeUtilRegionStatsTcb(*this, glob);
  
  exe_util_tcb->registerSubtasks();

  return (exe_util_tcb);
}

////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilRegionStatsTcb
///////////////////////////////////////////////////////////////
ExExeUtilRegionStatsTcb::ExExeUtilRegionStatsTcb(
     const ComTdbExeUtilRegionStats & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilTcb( exe_util_tdb, NULL, glob)
{
  statsBuf_ = new(glob->getDefaultHeap()) char[sizeof(ComTdbRegionStatsVirtTableColumnStruct)];
  statsBufLen_ = sizeof(ComTdbRegionStatsVirtTableColumnStruct);

  stats_ = (ComTdbRegionStatsVirtTableColumnStruct*)statsBuf_;

  inputNameBuf_ = NULL;
  if (exe_util_tdb.inputExpr_)
    {
      inputNameBuf_ = new(glob->getDefaultHeap()) char[exe_util_tdb.inputRowlen_];
    }

  int jniDebugPort = 0;
  int jniDebugTimeout = 0;
  ehi_ = ExpHbaseInterface::newInstance(glob->getDefaultHeap(),
					(char*)"", //exe_util_tdb.server(), 
					(char*)"", //exe_util_tdb.zkPort(),
                                        jniDebugPort,
                                        jniDebugTimeout);

  regionInfoList_ = NULL;
  
  tableName_ = new(glob->getDefaultHeap()) char[2000];

  // get hbase rootdir location. Max linux pathlength is 1024.
  hbaseRootdir_ = new(glob->getDefaultHeap()) char[1030];
  strcpy(hbaseRootdir_, "/hbase");

  step_ = INITIAL_;
}

ExExeUtilRegionStatsTcb::~ExExeUtilRegionStatsTcb()
{
  if (statsBuf_)
    NADELETEBASIC(statsBuf_, getGlobals()->getDefaultHeap());

  if (ehi_)
    delete ehi_;

  statsBuf_ = NULL;
}

//////////////////////////////////////////////////////
// work() for ExExeUtilRegionStatsTcb
//////////////////////////////////////////////////////
Int64 ExExeUtilRegionStatsTcb::getEmbeddedNumValue
(char* &sep, char endChar, NABoolean adjustLen)
{
  Int64 num = -1;
  char * sepEnd = strchr(sep+1, endChar);
  if (sepEnd)
    {
      char longBuf[30];

      Lng32 len = sepEnd - sep - 1;
      str_cpy_all(longBuf, (sep+1), len);
      longBuf[len] = 0;                
      
      num = str_atoi(longBuf, len);

      sep += len + 1;

      if ((adjustLen) && (num == 0))
        num = 1024;
    }

  return num;
}

short ExExeUtilRegionStatsTcb::collectStats(char * tableName)
{
  // populate catName_, schName_, objName_.
  if (extractParts(tableName,
                   &catName_, &schName_, &objName_))
    {
      return -1;
    }

  // collect stats from ehi.
  HbaseStr tblName;
  
  if (NAString(catName_) == HBASE_SYSTEM_CATALOG)
    extNameForHbase_ = NAString(objName_);
  else
    extNameForHbase_ =
      NAString(catName_) + "." + NAString(schName_) + "." + NAString(objName_);
  tblName.val = (char*)extNameForHbase_.data();
  tblName.len = extNameForHbase_.length();
  
  regionInfoList_ = ehi_->getRegionStats(tblName);
  if (! regionInfoList_)
    {
      return -1;
    }
 
  currIndex_ = 0;

  return 0;
}

short ExExeUtilRegionStatsTcb::populateStats
(Int32 currIndex)
{
  str_pad(stats_->catalogName, sizeof(stats_->catalogName), ' ');
  str_cpy_all(stats_->catalogName, catName_, strlen(catName_));

  str_pad(stats_->schemaName, sizeof(stats_->schemaName), ' ');
  str_cpy_all(stats_->schemaName, schName_, strlen(schName_));

  str_pad(stats_->objectName, sizeof(stats_->objectName), ' ');
  str_cpy_all(stats_->objectName, objName_, strlen(objName_));
  
  str_pad(stats_->regionServer, sizeof(stats_->regionServer), ' ');

  str_pad(stats_->regionName, sizeof(stats_->regionName), ' ');
  stats_->regionNum       = currIndex_+1;
  
  char regionInfoBuf[5000];
  Int32 len = 0;
  char *regionInfo = regionInfoBuf;
  char *val = regionInfoList_->at(currIndex).val;
  len = regionInfoList_->at(currIndex).len; 
  if (len >= sizeof(regionInfoBuf))
     len = sizeof(regionInfoBuf)-1;
  strncpy(regionInfoBuf, val, len);
  regionInfoBuf[len] = '\0';
  stats_->numStores                = 0;
  stats_->numStoreFiles            = 0;
  stats_->storeFileUncompSize      = 0;
  stats_->storeFileSize            = 0;
  stats_->memStoreSize             = 0;
  
  char longBuf[30];
  char * sep1 = strchr(regionInfo, '|');
  if (sep1)
    {
      str_cpy_all(stats_->regionServer, regionInfo, 
                  (Lng32)(sep1 - regionInfo)); 
    }

  char * sepStart = sep1+1;
  sep1 = strchr(sepStart, '|');
  if (sep1)
    {
      str_cpy_all(stats_->regionName, sepStart, 
                  (Lng32)(sep1 - sepStart)); 
    }
  
  sepStart = sep1;
  stats_->numStores = getEmbeddedNumValue(sepStart, '|', FALSE);
  stats_->numStoreFiles = getEmbeddedNumValue(sepStart, '|', FALSE);
  stats_->storeFileUncompSize = getEmbeddedNumValue(sepStart, '|', FALSE);
  stats_->storeFileSize = getEmbeddedNumValue(sepStart, '|', FALSE);
  stats_->memStoreSize = getEmbeddedNumValue(sepStart, '|', FALSE);
  stats_->readRequestsCount = getEmbeddedNumValue(sepStart, '|', FALSE);
  stats_->writeRequestsCount = getEmbeddedNumValue(sepStart, '|', FALSE);
  
  return 0;
}

short ExExeUtilRegionStatsTcb::work()
{
  short retcode = 0;
  Lng32 cliRC = 0;
  ex_expr::exp_return_type exprRetCode = ex_expr::EXPR_OK;

  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;
  
  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;
  
  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getCliGlobals()->currContext();

  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
            if (ehi_ == NULL)
              {
                step_ = HANDLE_ERROR_;
                break;
              }

            if (getDLStdb().inputExpr())
              {
                step_ = EVAL_INPUT_;
                break;
              }

            strcpy(tableName_, getDLStdb().getTableName());

	    step_ = COLLECT_STATS_;
	  }
	break;

        case EVAL_INPUT_:
          {
	    workAtp_->getTupp(getDLStdb().workAtpIndex())
	      .setDataPointer(inputNameBuf_);

	    ex_expr::exp_return_type exprRetCode =
	      getDLStdb().inputExpr()->eval(pentry_down->getAtp(), workAtp_);
	    if (exprRetCode == ex_expr::EXPR_ERROR)
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

            short len = *(short*)inputNameBuf_;
            str_cpy_all(tableName_, &inputNameBuf_[2], len);
            tableName_[len] = 0;

            step_ = COLLECT_STATS_;
          }
          break;

        case COLLECT_STATS_:
          {
            if (collectStats(tableName_))
              {
                step_ = HANDLE_ERROR_;
                break;
              }

            currIndex_ = 0;

            step_ = POPULATE_STATS_BUF_;
          }
          break;

	case POPULATE_STATS_BUF_:
	  {
            if (currIndex_ == regionInfoList_->entries())
              {
                step_ = DONE_;
                break;
              }
            
            if (populateStats(currIndex_))
              {
                step_ = HANDLE_ERROR_;
                break;
              }

	    step_ = EVAL_EXPR_;
	  }
	break;

        case EVAL_EXPR_:
          {
            exprRetCode = evalScanExpr((char*)stats_, statsBufLen_, FALSE);
	    if (exprRetCode == ex_expr::EXPR_FALSE)
	      {
		// row does not pass the scan expression,
		// move to the next row.
                currIndex_++;

		step_ = POPULATE_STATS_BUF_;
		break;
	      }
            
            step_ = RETURN_STATS_BUF_;
          }
          break;

	case RETURN_STATS_BUF_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    short rc = 0;
	    if (moveRowToUpQueue((char*)stats_, statsBufLen_, &rc, FALSE))
	      return rc;

            currIndex_++;

            step_ = POPULATE_STATS_BUF_;
	  }
	break;

	case HANDLE_ERROR_:
	  {
	    retcode = handleError();
	    if (retcode == 1)
	      return WORK_OK;
	    
	    step_ = DONE_;
	  }
	break;
	
	case DONE_:
	  {
            if (regionInfoList_ != NULL) {
               deleteNAArray(getHeap(), regionInfoList_);
               regionInfoList_ = NULL;
            }
	    retcode = handleDone();
	    if (retcode == 1)
	      return WORK_OK;
	    
	    step_ = INITIAL_;
	    
	    return WORK_CALL_AGAIN;
	  }
	break;


	} // switch

    } // while

  return WORK_OK;
}

/////////////////////////////////////////////////////////////////////////////
// Constructor and destructor for ExeUtil_private_state
/////////////////////////////////////////////////////////////////////////////
ExExeUtilRegionStatsPrivateState::ExExeUtilRegionStatsPrivateState()
{
}

ExExeUtilRegionStatsPrivateState::~ExExeUtilRegionStatsPrivateState()
{
};


////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilRegionStatsFormatTcb
///////////////////////////////////////////////////////////////
ExExeUtilRegionStatsFormatTcb::ExExeUtilRegionStatsFormatTcb(
     const ComTdbExeUtilRegionStats & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilRegionStatsTcb( exe_util_tdb, glob)
{
  statsTotalsBuf_ = new(glob->getDefaultHeap()) char[sizeof(ComTdbRegionStatsVirtTableColumnStruct)];

  statsTotals_ = (ComTdbRegionStatsVirtTableColumnStruct*)statsTotalsBuf_;

  initTotals();

  step_ = INITIAL_;
}

static NAString removeTrailingBlanks(char * name, Lng32 maxLen)
{
  NAString nas;
  
  if (! name)
    return nas;

  Lng32 i = maxLen;
  while ((i > 0) && (name[i-1] == ' '))
    {
      i--;
    }

  if (i > 0)
    nas = NAString(name, i);

  return nas;
}

short ExExeUtilRegionStatsFormatTcb::initTotals()
{
  statsTotals_->numStores                 = 0;
  statsTotals_->numStoreFiles             = 0;
  statsTotals_->readRequestsCount         = 0;
  statsTotals_->writeRequestsCount        = 0;
  statsTotals_->storeFileUncompSize      = 0;
  statsTotals_->storeFileSize            = 0;
  statsTotals_->memStoreSize             = 0;

  return 0;
}

short ExExeUtilRegionStatsFormatTcb::computeTotals()
{
  str_pad(statsTotals_->catalogName, sizeof(statsTotals_->catalogName), ' ');
  str_cpy_all(statsTotals_->catalogName, catName_, strlen(catName_));

  str_pad(statsTotals_->schemaName, sizeof(statsTotals_->schemaName), ' ');
  str_cpy_all(statsTotals_->schemaName, schName_, strlen(schName_));

  str_pad(statsTotals_->objectName, sizeof(statsTotals_->objectName), ' ');
  str_cpy_all(statsTotals_->objectName, objName_, strlen(objName_));

  str_pad(statsTotals_->regionServer, sizeof(statsTotals_->regionServer), ' ');

  str_pad(statsTotals_->regionName, sizeof(statsTotals_->regionName), ' ');

  for (Int32 currIndex = 0; currIndex < regionInfoList_->entries(); currIndex++)
    {
      if (populateStats(currIndex))
        return -1;

      statsTotals_->numStores           += stats_->numStores;
      statsTotals_->numStoreFiles       += stats_->numStoreFiles;
      statsTotals_->storeFileUncompSize += stats_->storeFileUncompSize;
      statsTotals_->storeFileSize       += stats_->storeFileSize;
      statsTotals_->memStoreSize        += stats_->memStoreSize;  
      statsTotals_->readRequestsCount   += stats_->readRequestsCount;
      statsTotals_->writeRequestsCount  += stats_->writeRequestsCount;
    }
  
  return 0;
}

short ExExeUtilRegionStatsFormatTcb::work()
{
  short retcode = 0;
  Lng32 cliRC = 0;

  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;
  
  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;
  
  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getCliGlobals()->currContext();

  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
            if (ehi_ == NULL)
              {
                step_ = HANDLE_ERROR_;
                break;
              }
            
            initTotals();
            
            if (getDLStdb().inputExpr())
              {
                step_ = EVAL_INPUT_;
                break;
              }

            strcpy(tableName_, getDLStdb().getTableName());

	    step_ = COLLECT_STATS_;
	  }
	break;

        case EVAL_INPUT_:
          {
	    workAtp_->getTupp(getDLStdb().workAtpIndex())
	      .setDataPointer(inputNameBuf_);

	    ex_expr::exp_return_type exprRetCode =
	      getDLStdb().inputExpr()->eval(pentry_down->getAtp(), workAtp_);
	    if (exprRetCode == ex_expr::EXPR_ERROR)
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

            short len = *(short*)inputNameBuf_;
            str_cpy_all(tableName_, &inputNameBuf_[2], len);
            tableName_[len] = 0;

            step_ = COLLECT_STATS_;
          }
          break;

        case COLLECT_STATS_:
          {
            if (collectStats(tableName_))
              {
                step_ = HANDLE_ERROR_;
                break;
              }

            currIndex_ = 0;

            step_ = COMPUTE_TOTALS_;
          }
          break;

        case COMPUTE_TOTALS_:
          {
            if (computeTotals())
              {
                step_ = HANDLE_ERROR_;
                break;
              }

            step_ = RETURN_SUMMARY_;
          }
          break;

        case RETURN_SUMMARY_:
          {
	    // make sure there is enough space to move header
	    if (isUpQueueFull(14))
	      {
		return WORK_CALL_AGAIN; // come back later
	      }

            ULng32 neededSize = SqlBufferNeededSize(14, 250);
            if (! pool_->get_free_buffer(neededSize))
              {
                return WORK_CALL_AGAIN;
              }
            
            char buf[1000];
	    short rc = 0;

            str_sprintf(buf, " ");
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "Stats Summary");
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;
 
            str_sprintf(buf, "=============");
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, " ");
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            NAString objName = extNameForHbase_;
            str_sprintf(buf, "  ObjectName:              %s", objName.data());
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "  NumRegions:              %d", regionInfoList_->entries());
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "  RegionsLocation:         %s/data/default", 
                        hbaseRootdir_);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "  TotalNumStores:          %d", statsTotals_->numStores);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "  TotalNumStoreFiles:      %d", statsTotals_->numStoreFiles);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "  TotalUncompressedSize:   %Ld", statsTotals_->storeFileUncompSize);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

           str_sprintf(buf, "  TotalStoreFileSize:      %Ld", statsTotals_->storeFileSize);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "  TotalMemStoreSize:       %Ld", statsTotals_->memStoreSize);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "  TotalReadRequestsCount:  %Ld", statsTotals_->readRequestsCount);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "  TotalWriteRequestsCount: %Ld", statsTotals_->writeRequestsCount);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            step_ = RETURN_DETAILS_;
            return WORK_RESCHEDULE_AND_RETURN;
          }
          break;

        case RETURN_DETAILS_:
          {

            if ((getDLStdb().summaryOnly()) ||
                (regionInfoList_->entries() == 0))
              {
                step_ = DONE_;
                break;
              }

	    // make sure there is enough space to move header
	    if (isUpQueueFull(4))
	      {
		return WORK_CALL_AGAIN; // come back later
	      }

            ULng32 neededSize = SqlBufferNeededSize(4, 250);
            if (! pool_->get_free_buffer(neededSize))
              {
                return WORK_CALL_AGAIN;
              }

            char buf[1000];
	    short rc = 0;

            str_sprintf(buf, " ");
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "Stats Details");
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;
 
            str_sprintf(buf, "=============");
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, " ");
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            currIndex_ = 0;
            step_ = POPULATE_STATS_BUF_;

            return WORK_RESCHEDULE_AND_RETURN;
          }
          break;

	case POPULATE_STATS_BUF_:
	  {
            if (currIndex_ == regionInfoList_->entries())
              {
                step_ = DONE_;
                break;
              }
            
            if (populateStats(currIndex_))
              {
                step_ = HANDLE_ERROR_;
                break;
              }

            step_ = RETURN_REGION_INFO_;
          }
          break;

        case RETURN_REGION_INFO_:
          {
	    // make sure there is enough space to move header
	    if (isUpQueueFull(10))
	      {
		return WORK_CALL_AGAIN; // come back later
	      }

            ULng32 neededSize = SqlBufferNeededSize(4, 100);
            if (! pool_->get_free_buffer(neededSize))
              {
                return WORK_CALL_AGAIN;
              }

            char buf[1000];
	    short rc = 0;

            str_sprintf(buf, "  RegionServer:       %s", 
                        removeTrailingBlanks(stats_->regionServer, STATS_NAME_MAX_LEN).data(), TRUE);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;
  
            str_sprintf(buf, "  RegionNum:          %d", currIndex_+1);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "  RegionName:         %s", 
                        removeTrailingBlanks(stats_->regionName, STATS_REGION_NAME_MAX_LEN).data(), TRUE);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;
            
            str_sprintf(buf, "  NumStores:          %d", stats_->numStores);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "  NumStoreFiles:      %d", stats_->numStoreFiles);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            if (stats_->storeFileUncompSize == 0)
              str_sprintf(buf, "  UncompressedSize:   %Ld (less than 1MB)", stats_->storeFileUncompSize);
            else
              str_sprintf(buf, "  UncompressedSize:   %Ld Bytes", stats_->storeFileUncompSize);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            if (stats_->storeFileSize == 0)
              str_sprintf(buf, "  StoreFileSize:      %Ld (less than 1MB)", stats_->storeFileSize);
            else
              str_sprintf(buf, "  StoreFileSize:      %Ld Bytes", stats_->storeFileSize);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            if (stats_->memStoreSize == 0)
              str_sprintf(buf, "  MemStoreSize:       %Ld (less than 1MB)", stats_->memStoreSize);
            else
              str_sprintf(buf, "  MemStoreSize:       %Ld Bytes", stats_->memStoreSize);              
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "  ReadRequestsCount:  %Ld", stats_->readRequestsCount);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "  WriteRequestsCount: %Ld", stats_->writeRequestsCount);
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            str_sprintf(buf, "   ");
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;

            currIndex_++;

            step_ = POPULATE_STATS_BUF_;

            return WORK_RESCHEDULE_AND_RETURN;
          }
          break;

	case HANDLE_ERROR_:
	  {
	    retcode = handleError();
	    if (retcode == 1)
	      return WORK_OK;
	    
	    step_ = DONE_;
	  }
	break;
	
	case DONE_:
	  {
            if (regionInfoList_ != NULL) {
               deleteNAArray(getHeap(), regionInfoList_);
               regionInfoList_ = NULL;
            }
	    retcode = handleDone();
	    if (retcode == 1)
	      return WORK_OK;
	    
	    step_ = INITIAL_;
	    
	    return WORK_CALL_AGAIN;
	  }
	break;


	} // switch

    } // while

  return WORK_OK;
}

////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilClusterStatsTcb
///////////////////////////////////////////////////////////////
ExExeUtilClusterStatsTcb::ExExeUtilClusterStatsTcb(
     const ComTdbExeUtilRegionStats & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilRegionStatsTcb( exe_util_tdb, glob)
{
  statsBuf_ = new(glob->getDefaultHeap()) char[sizeof(ComTdbClusterStatsVirtTableColumnStruct)];
  statsBufLen_ = sizeof(ComTdbClusterStatsVirtTableColumnStruct);

  stats_ = (ComTdbClusterStatsVirtTableColumnStruct*)statsBuf_;

  int jniDebugPort = 0;
  int jniDebugTimeout = 0;
  ehi_ = ExpHbaseInterface::newInstance(glob->getDefaultHeap(),
					(char*)"", //exe_util_tdb.server(), 
					(char*)"", //exe_util_tdb.zkPort(),
                                        jniDebugPort,
                                        jniDebugTimeout);

  regionInfoList_ = NULL;
  
  // get hbase rootdir location. Max linux pathlength is 1024.
  hbaseRootdir_ = new(glob->getDefaultHeap()) char[1030];
  strcpy(hbaseRootdir_, "/hbase");

  step_ = INITIAL_;
}

ExExeUtilClusterStatsTcb::~ExExeUtilClusterStatsTcb()
{
  if (statsBuf_)
    NADELETEBASIC(statsBuf_, getGlobals()->getDefaultHeap());

  if (ehi_)
    delete ehi_;

  statsBuf_ = NULL;
}

short ExExeUtilClusterStatsTcb::collectStats()
{
  numRegionStatsEntries_ = 0;
  regionInfoList_ = ehi_->getClusterStats(numRegionStatsEntries_);
  if (! regionInfoList_)
    {
      return 1; // EOD
    }
 
  currIndex_ = 0;

  return 0;
}

// RETURN: 1, not a TRAFODION region. 0, is a TRAFODION region.
//        -1, error.
short ExExeUtilClusterStatsTcb::populateStats
(Int32 currIndex, NABoolean nullTerminate)
{
  str_pad(stats_->catalogName, sizeof(stats_->catalogName), ' ');
  str_pad(stats_->schemaName, sizeof(stats_->schemaName), ' ');
  str_pad(stats_->objectName, sizeof(stats_->objectName), ' ');

  str_pad(stats_->regionServer, sizeof(stats_->regionServer), ' ');

  str_pad(stats_->regionName, sizeof(stats_->regionName), ' ');
   
  char regionInfoBuf[5000];
  Int32 len = 0;
  char *regionInfo = regionInfoBuf;
  char *val = regionInfoList_->at(currIndex).val;
  len = regionInfoList_->at(currIndex).len; 
  if (len >= sizeof(regionInfoBuf))
     len = sizeof(regionInfoBuf)-1;
  strncpy(regionInfoBuf, val, len);
  regionInfoBuf[len] = '\0';
  stats_->numStores                = 0;
  stats_->numStoreFiles            = 0;
  stats_->storeFileUncompSize      = 0;
  stats_->storeFileSize            = 0;
  stats_->memStoreSize             = 0;
  
  char longBuf[30];
  char * sep1 = strchr(regionInfo, '|');
  if (sep1)
    {
      str_cpy_all(stats_->regionServer, regionInfo, 
                  (Lng32)(sep1 - regionInfo)); 

      if (nullTerminate)
        stats_->regionServer[sep1 - regionInfo] = 0;
    }

  char * sepStart = sep1+1;
  sep1 = strchr(sepStart, '|');
  if (sep1)
    {
      str_cpy_all(stats_->regionName, sepStart, 
                  (Lng32)(sep1 - sepStart)); 

      if (nullTerminate)
        stats_->regionName[sep1 - sepStart] = 0;
    }

  char tableName[3*STATS_NAME_MAX_LEN + 3];
  sepStart = sep1+1;
  sep1 = strchr(sepStart, '|');
  if (sep1)
    {
      str_cpy_all(tableName, sepStart, 
                  (Lng32)(sep1 - sepStart)); 

      tableName[sep1 - sepStart] = 0;

      char tableNameBuf[3*STATS_NAME_MAX_LEN + 30];

      Lng32 numParts = 0;
      char *parts[4];
      LateNameInfo::extractParts(tableName, tableNameBuf, numParts, parts, FALSE);

      if (numParts == 3)
        {
          str_cpy_all(stats_->catalogName, parts[0], strlen(parts[0]));
          if (nullTerminate)
            stats_->catalogName[strlen(parts[0])] = 0;

          str_cpy_all(stats_->schemaName, parts[1], strlen(parts[1]));
          if (nullTerminate)
            stats_->schemaName[strlen(parts[1])] = 0;
      
          str_cpy_all(stats_->objectName, parts[2], strlen(parts[2]));
          if (nullTerminate)
            stats_->objectName[strlen(parts[2])] = 0;
        }

      if ((numParts != 3) ||
          (str_cmp(stats_->catalogName, TRAFODION_SYSCAT_LIT, strlen(TRAFODION_SYSCAT_LIT)) != 0))
        {
          // this is not a trafodion region, skip it.
          return 1;
        }
    }
  
  sepStart = sep1;
  stats_->numStores = getEmbeddedNumValue(sepStart, '|', FALSE);
  stats_->numStoreFiles = getEmbeddedNumValue(sepStart, '|', FALSE);
  stats_->storeFileUncompSize = getEmbeddedNumValue(sepStart, '|', FALSE);
  stats_->storeFileSize = getEmbeddedNumValue(sepStart, '|', FALSE);
  stats_->memStoreSize = getEmbeddedNumValue(sepStart, '|', FALSE);
  stats_->readRequestsCount = getEmbeddedNumValue(sepStart, '|', FALSE);
  stats_->writeRequestsCount = getEmbeddedNumValue(sepStart, '|', FALSE);
  
  return 0;
}

short ExExeUtilClusterStatsTcb::work()
{
  short retcode = 0;
  Lng32 cliRC = 0;
  ex_expr::exp_return_type exprRetCode = ex_expr::EXPR_OK;

  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;
  
  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;
  
  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getCliGlobals()->currContext();

  ComDiagsArea * diags = getDiagsArea();

  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
            if (ehi_ == NULL)
              {
                step_ = HANDLE_ERROR_;
                break;
              }

	    step_ = COLLECT_STATS_;
	  }
	break;

       case COLLECT_STATS_:
          {
            retcode = collectStats();
            if (retcode == 1) // EOD
              {
                step_ = DONE_;
                break;
              }
            else if (retcode < 0)
              {
		*diags << DgSqlCode(-8451);

                step_ = HANDLE_ERROR_;
                break;
              }

            currIndex_ = 0;

            step_ = POPULATE_STATS_BUF_;
          }
          break;

	case POPULATE_STATS_BUF_:
	  {
            if (currIndex_ == numRegionStatsEntries_) //regionInfoList_->entries())
              {
                step_ = COLLECT_STATS_;
                break;
              }
            
            retcode = populateStats(currIndex_);
            if (retcode == 1) // not TRAFODION region, skip it
              {
                currIndex_++;

                step_ = POPULATE_STATS_BUF_;
                break;
              }
            else if (retcode < 0)
              {
                step_ = HANDLE_ERROR_;
                break;
              }

	    step_ = EVAL_EXPR_;
	  }
	break;

        case EVAL_EXPR_:
          {
            exprRetCode = evalScanExpr((char*)stats_, statsBufLen_, FALSE);
	    if (exprRetCode == ex_expr::EXPR_FALSE)
	      {
		// row does not pass the scan expression,
		// move to the next row.
                currIndex_++;

		step_ = POPULATE_STATS_BUF_;
		break;
	      }
            
            step_ = RETURN_STATS_BUF_;
          }
          break;

	case RETURN_STATS_BUF_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    short rc = 0;
	    if (moveRowToUpQueue((char*)stats_, statsBufLen_, &rc, FALSE))
	      return rc;

 
            currIndex_++;

            step_ = POPULATE_STATS_BUF_;
	  }
	break;

	case HANDLE_ERROR_:
	  {
	    retcode = handleError();
	    if (retcode == 1)
	      return WORK_OK;
	    
	    step_ = DONE_;
	  }
	break;
	
	case DONE_:
	  {
            if (regionInfoList_ != NULL) {
               deleteNAArray(getHeap(), regionInfoList_);
               regionInfoList_ = NULL;
            }
	    retcode = handleDone();
	    if (retcode == 1)
	      return WORK_OK;
	    
	    step_ = INITIAL_;
	    
	    return WORK_CALL_AGAIN;
	  }
	break;


	} // switch

    } // while

  return WORK_OK;
}


///////////////////////////////////////////////////////////////////
ex_tcb * ExExeUtilLobInfoTdb::build(ex_globals * glob)
{

  if (isTableFormat())
    {
      ExExeUtilLobInfoTableTcb *exe_util_tcb = new(glob->getSpace()) ExExeUtilLobInfoTableTcb(*this,glob);
      exe_util_tcb->registerSubtasks();

      return (exe_util_tcb);
    }
  else
    {


    ExExeUtilLobInfoTcb *exe_util_tcb = new(glob->getSpace()) ExExeUtilLobInfoTcb(*this, glob);
    exe_util_tcb->registerSubtasks();

    return (exe_util_tcb);
    }
 
}

////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilLobInfoTcb
///////////////////////////////////////////////////////////////
ExExeUtilLobInfoTcb::ExExeUtilLobInfoTcb(
     const ComTdbExeUtilLobInfo & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilTcb( exe_util_tdb, NULL, glob)
{
  

  inputNameBuf_ = NULL;
  if (exe_util_tdb.inputExpr_)
    {
      inputNameBuf_ = new(glob->getDefaultHeap()) char[exe_util_tdb.inputRowlen_];
    }

  tableName_ = new(glob->getDefaultHeap()) char[2000];
  currLobNum_ = 1;
  step_ = INITIAL_;
}

ExExeUtilLobInfoTcb::~ExExeUtilLobInfoTcb()
{
  if (tableName_)
    NADELETEBASIC(tableName_, getGlobals()->getDefaultHeap());
  if(inputNameBuf_) 
     NADELETEBASIC(inputNameBuf_, getGlobals()->getDefaultHeap());
 
  tableName_ = NULL;
  inputNameBuf_ = NULL;
}

short ExExeUtilLobInfoTcb::collectAndReturnLobInfo(char * tableName,Int32 currLobNum, ContextCli *currContext)
{
  char *catName = NULL;
  char *schName = NULL;
  char *objName = NULL;
  Int32 offset = 0;
  char columnName[LOBINFO_MAX_FILE_LEN]= {'\0'};
  char lobLocation[LOBINFO_MAX_FILE_LEN]={'\0'};
  char lobDataFilePath[LOBINFO_MAX_FILE_LEN]={'\0'};
  Int64 lobEOD=0;

  char buf[LOBINFO_MAX_FILE_LEN+500];
  short rc = 0;
  if (isUpQueueFull(5))
    {
      return WORK_CALL_AGAIN; // come back later
    }
  

  // populate catName, schName, objName.
  if (extractParts(tableName,
                   &catName, &schName, &objName))
    {
      return -1;
    }
  str_pad(buf,sizeof(buf),' ');
  //column name
  offset = (currLobNum-1)*LOBINFO_MAX_FILE_LEN; 
  strcpy(columnName, &((getLItdb().getLobColList())[offset]));
  removeTrailingBlanks(columnName, LOBINFO_MAX_FILE_LEN);
  str_sprintf(buf, "  ColumnName :  %s", columnName);
  if (moveRowToUpQueue(buf, strlen(buf), &rc))
    return rc;

  //lob location  
 
   strcpy(lobLocation, &((getLItdb().getLobLocList())[offset]));
  removeTrailingBlanks(lobLocation, LOBINFO_MAX_FILE_LEN);
if (getLItdb().getLobTypeList()[(currLobNum-1)*sizeof(Int32)] == Lob_External_HDFS_File)
  str_sprintf(buf, "  Lob Location :  External HDFS Location");
else
  str_sprintf(buf, "  Lob Location :  %s", lobLocation);
  if (moveRowToUpQueue(buf, strlen(buf), &rc))
    return rc;      
  
  char lobDescChunkFileBuf[LOBINFO_MAX_FILE_LEN*2];
  //Get the descriptor chunks table name
  char *lobDescChunksFile =
    ExpLOBoper::ExpGetLOBDescChunksName(strlen(schName),schName,
                                        getLItdb().objectUID_, currLobNum, 
                                        lobDescChunkFileBuf, LOBINFO_MAX_FILE_LEN*2);
 
  char *query = new(getGlobals()->getDefaultHeap()) char[4096]; 
  // lobDataFile
  char tgtLobNameBuf[LOBINFO_MAX_FILE_LEN];
 
  
   char *lobDataFile = 
     ExpLOBoper::ExpGetLOBname
     (getLItdb().objectUID_, currLobNum, 
      tgtLobNameBuf, LOBINFO_MAX_FILE_LEN);
    
    
 
  removeTrailingBlanks(lobDataFile, LOBINFO_MAX_FILE_LEN);
  if (getLItdb().getLobTypeList()[(currLobNum-1)*sizeof(Int32)] == Lob_External_HDFS_File)
    str_sprintf(buf, "  LOB Data File:  External HDFS File");
  else
    str_sprintf(buf, "  LOB Data File:  %s", lobDataFile);
  if (moveRowToUpQueue(buf, strlen(buf), &rc))
    return rc;  
                
  //EOD of LOB data file
  
  hdfsFS fs = currContext->getHdfsServerConnection((char*)getLItdb().getHdfsServer(),getLItdb().getHdfsPort());
  if (fs == NULL)
    return LOB_DATA_FILE_OPEN_ERROR;

  
  snprintf(lobDataFilePath, LOBINFO_MAX_FILE_LEN, "%s/%s", lobLocation, lobDataFile);
  hdfsFile fdData = hdfsOpenFile(fs, lobDataFilePath,O_RDONLY,0,0,0);
  if (!fdData) 
    {
      hdfsCloseFile(fs,fdData);
      fdData = NULL;
      return LOB_DATA_FILE_OPEN_ERROR;
    }
  hdfsFileInfo *fInfo = hdfsGetPathInfo(fs, lobDataFilePath);
  if (fInfo)
    lobEOD = fInfo->mSize;
  else
    lobEOD = 0;
  
  str_sprintf(buf, "  LOB EOD :  %Ld", lobEOD);
  if (moveRowToUpQueue(buf, strlen(buf), &rc))
    return rc;

  // Sum of all the lobDescChunks for used space

   
  str_sprintf (query,  "select sum(chunklen) from  %s ", lobDescChunksFile);
  // set parserflags to allow ghost table
  currContext->setSqlParserFlags(0x1);	

  Int64 outlen = 0;Lng32 len = 0;
  Int32 cliRC = cliInterface()->executeImmediate(query,(char *)&outlen, &len, FALSE);
  if ((len ==0) ||(getLItdb().getLobTypeList()[(currLobNum-1)*sizeof(Int32)] == Lob_External_HDFS_File))
    outlen = 0;
  NADELETEBASIC(query, getGlobals()->getDefaultHeap());
  
  currContext->resetSqlParserFlags(0x1);
  if (cliRC <0 )
    {
      return cliRC;
    }

  str_sprintf(buf, "  LOB Used Len :  %Ld", outlen);
  if (moveRowToUpQueue(buf, strlen(buf), &rc))
    return rc;
  return 0;
}
short ExExeUtilLobInfoTcb::work()
{
  short retcode = 0;
  Lng32 cliRC = 0;
  const char *parentQid = NULL;
  char buf[1000];
     short rc = 0;
  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;
  
  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;
  
  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getCliGlobals()->currContext();
   ExExeStmtGlobals *stmtGlobals = getGlobals()->castToExExeStmtGlobals();
  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
            if (isUpQueueFull(3))
	      {
		return WORK_CALL_AGAIN; // come back later
	      }
           
             
            if (getLItdb().inputExpr())
              {
                step_ = EVAL_INPUT_;
                break;
              }

            strcpy(tableName_, getLItdb().getTableName());
            str_pad(buf,1000,'\0');
            str_sprintf(buf, " ");
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
              return rc;
            removeTrailingBlanks(tableName_, LOBINFO_MAX_FILE_LEN);
            str_pad(buf,1000,'\0');
            str_sprintf(buf, "Lob Information for table: %s", tableName_);
            if (moveRowToUpQueue(buf, strlen(buf), &rc))
              return rc;
            str_pad(buf,1000,'\0');
             str_sprintf(buf, "=========================");
            if (moveRowToUpQueue(buf, strlen(buf), &rc))
              return rc;
            str_pad(buf,1000,'\0');
            str_sprintf(buf, " ");
	    if (moveRowToUpQueue(buf, strlen(buf), &rc))
	      return rc;
            
	    step_ = COLLECT_LOBINFO_;
           
	  }
	break;

        case EVAL_INPUT_:
          {
	    workAtp_->getTupp(getLItdb().workAtpIndex())
	      .setDataPointer(inputNameBuf_);

	    ex_expr::exp_return_type exprRetCode =
	      getLItdb().inputExpr()->eval(pentry_down->getAtp(), workAtp_);
	    if (exprRetCode == ex_expr::EXPR_ERROR)
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

            short len = *(short*)inputNameBuf_;
            str_cpy_all(tableName_, &inputNameBuf_[2], len);
            tableName_[len] = 0;

           
            step_ = COLLECT_LOBINFO_;
          }
          break;

        case COLLECT_LOBINFO_:
          {
            if (getLItdb().getNumLobs() == 0)
              {
                str_sprintf(buf, "  Num Lob Columns = 0", tableName_);
                if (moveRowToUpQueue(buf, strlen(buf), &rc))
                  return rc;
                step_ = DONE_;
                break;
              }
            if (currLobNum_ == getLItdb().getNumLobs()+1)
              {
                step_ = DONE_;
                break;
              }
            if (collectAndReturnLobInfo(tableName_,currLobNum_, currContext))
              {
                step_ = HANDLE_ERROR_;
                break;
              }
            currLobNum_++;
            
          }
          break;



	case HANDLE_ERROR_:
	  {
            
	    retcode = handleError();
	    if (retcode == 1)
	      return WORK_OK;
	    
	    step_ = DONE_;
	  }
	break;
	
	case DONE_:
	  {
           
	    retcode = handleDone();
	    if (retcode == 1)
	      return WORK_OK;
	    
	    step_ = INITIAL_;
	    
	    return WORK_OK;
	  }
	break;


	} // switch

    } // while

  return WORK_OK;
}
//LCOV_EXCL_STOP



////////////////////////////////////////////////////////////////
// Constructor for class ExExeUtilLobInfoTableTcb
///////////////////////////////////////////////////////////////
ExExeUtilLobInfoTableTcb::ExExeUtilLobInfoTableTcb(
     const ComTdbExeUtilLobInfo & exe_util_tdb,
     ex_globals * glob)
     : ExExeUtilTcb( exe_util_tdb, NULL, glob)
{
  lobInfoBuf_ = new(glob->getDefaultHeap()) char[sizeof(ComTdbLobInfoVirtTableColumnStruct)];
  lobInfoBufLen_ = sizeof(ComTdbLobInfoVirtTableColumnStruct);

  lobInfo_ = (ComTdbLobInfoVirtTableColumnStruct*)lobInfoBuf_;

  inputNameBuf_ = NULL;
  if (exe_util_tdb.inputExpr_)
    {
      inputNameBuf_ = new(glob->getDefaultHeap()) char[exe_util_tdb.inputRowlen_];
    }

  
  tableName_ = new(glob->getDefaultHeap()) char[2000];
  currLobNum_ = 1;
  step_ = INITIAL_;
}

ExExeUtilLobInfoTableTcb::~ExExeUtilLobInfoTableTcb()
{
  if (lobInfoBuf_)
    NADELETEBASIC(lobInfoBuf_, getGlobals()->getDefaultHeap());
  if (tableName_)
    NADELETEBASIC(tableName_, getGlobals()->getDefaultHeap());
  if(inputNameBuf_) 
     NADELETEBASIC(inputNameBuf_, getGlobals()->getDefaultHeap());

  tableName_ = NULL;
  inputNameBuf_ = NULL;

  lobInfoBuf_ = NULL;
}
short ExExeUtilLobInfoTableTcb:: populateLobInfo(Int32 currIndex, NABoolean nullTerminate )
{
  return 0;
}
short ExExeUtilLobInfoTableTcb::collectLobInfo(char * tableName,Int32 currLobNum, ContextCli *currContext)
{
  char *catName = NULL;
  char *schName = NULL;
  char *objName = NULL;
  Int32 offset = 0;
  char columnName[LOBINFO_MAX_FILE_LEN]= {'\0'};
  char lobDataFilePath[LOBINFO_MAX_FILE_LEN]={'\0'};
  Int64 lobEOD=0;

  // populate catName, schName, objName.
  if (extractParts(tableName,
                   &catName, &schName, &objName))
    {
      return -1;
    }
  str_pad((char *)lobInfo_,sizeof(ComTdbLobInfoVirtTableColumnStruct),' ');
  
  str_cpy_all(lobInfo_->catalogName,catName,strlen(catName));
  str_cpy_all(lobInfo_->schemaName,schName,strlen(schName));
  str_cpy_all(lobInfo_->objectName,objName,strlen(objName));

  //column name
  offset = (currLobNum-1)*LOBINFO_MAX_FILE_LEN; 
  str_cpy_all(lobInfo_->columnName, &((getLItdb().getLobColList())[offset]),
              strlen(&((getLItdb().getLobColList())[offset])));

  char *lobLocation = new(getGlobals()->getDefaultHeap()) char[LOBINFO_MAX_FILE_LEN]  ;
 
   
  lobLocation = &((getLItdb().getLobLocList())[offset]);
 if (getLItdb().getLobTypeList()[(currLobNum-1)*sizeof(Int32)] == Lob_External_HDFS_File)
 str_cpy_all(lobInfo_->lobLocation, "External HDFS Location", strlen("External HDFS Location"));
 else 
   str_cpy_all(lobInfo_->lobLocation, (char *)&lobLocation[0], strlen(lobLocation));
                          
  // lobDataFile
  char tgtLobNameBuf[LOBINFO_MAX_FILE_LEN];
  char query[4096];
  char lobDescChunkFileBuf[LOBINFO_MAX_FILE_LEN*2];
 
  //Get the descriptor chunks table name
  char *lobDescChunksFile =
    ExpLOBoper::ExpGetLOBDescChunksName(strlen(schName),schName,
                                        getLItdb().objectUID_, currLobNum, 
                                        lobDescChunkFileBuf, LOBINFO_MAX_FILE_LEN*2);
    char *lobDataFile = 
	      ExpLOBoper::ExpGetLOBname
      (getLItdb().objectUID_, currLobNum, 
	       tgtLobNameBuf, LOBINFO_MAX_FILE_LEN);
   
  if (getLItdb().getLobTypeList()[(currLobNum-1)*sizeof(Int32)] == Lob_External_HDFS_File)
    {
      str_cpy_all(lobInfo_->lobDataFile, "External HDFS File" ,strlen("External HDFS File"));  
    }
  else
    {
      str_cpy_all(lobInfo_->lobDataFile,  lobDataFile,strlen(lobDataFile));
    }             
  //EOD of LOB data file
  // hdfsFS fs = hdfsConnect(getLItdb().getHdfsServer(),getLItdb().getHdfsPort());
  hdfsFS fs = currContext->getHdfsServerConnection((char*)getLItdb().getHdfsServer(),getLItdb().getHdfsPort());
  if (fs == NULL)
    return LOB_DATA_FILE_OPEN_ERROR;

  snprintf(lobDataFilePath, LOBINFO_MAX_FILE_LEN, "%s/%s", lobLocation, lobDataFile);
  hdfsFile fdData = hdfsOpenFile(fs, lobDataFilePath,O_RDONLY,0,0,0);
  if (!fdData) 
    {
      hdfsCloseFile(fs,fdData);
      fdData = NULL;
      return LOB_DATA_FILE_OPEN_ERROR;
    }
  hdfsFileInfo *fInfo = hdfsGetPathInfo(fs, lobDataFilePath);
  if (fInfo)
    lobEOD = fInfo->mSize;
  else
    lobEOD = 0;
  lobInfo_->lobDataFileSizeEod=lobEOD;
  // Sum of all the lobDescChunks for used space

  str_sprintf (query,  "select sum(chunklen) from  %s ", lobDescChunksFile);

  // set parserflags to allow ghost table
  currContext->setSqlParserFlags(0x1);
	
  Int64 outlen = 0;Lng32 len = 0;
  Int32 cliRC = cliInterface()->executeImmediate(query,(char *)&outlen, &len, FALSE);
  if ((len == 0) || (getLItdb().getLobTypeList()[(currLobNum-1)*sizeof(Int32)] == Lob_External_HDFS_File))
    outlen = 0;
  lobInfo_->lobDataFileSizeUsed = outlen;
  currContext->resetSqlParserFlags(0x1);
        

  if (cliRC <0 )
    {
      return cliRC;
    }
  
  return 0;
}
short ExExeUtilLobInfoTableTcb::work()
{
  short retcode = 0;
  Lng32 cliRC = 0;
  const char *parentQid = NULL;
  // if no parent request, return
  if (qparent_.down->isEmpty())
    return WORK_OK;
  
  // if no room in up queue, won't be able to return data/status.
  // Come back later.
  if (qparent_.up->isFull())
    return WORK_OK;
  
  ex_queue_entry * pentry_down = qparent_.down->getHeadEntry();
  ExExeUtilPrivateState & pstate =
    *((ExExeUtilPrivateState*) pentry_down->pstate);

  // Get the globals stucture of the master executor.
  ExExeStmtGlobals *exeGlob = getGlobals()->castToExExeStmtGlobals();
  ExMasterStmtGlobals *masterGlob = exeGlob->castToExMasterStmtGlobals();
  ContextCli * currContext = masterGlob->getCliGlobals()->currContext();
  
  ExExeStmtGlobals *stmtGlobals = getGlobals()->castToExExeStmtGlobals();
  if (stmtGlobals->castToExMasterStmtGlobals())
    parentQid = stmtGlobals->castToExMasterStmtGlobals()->
      getStatement()->getUniqueStmtId();
  else 
  {
    ExEspStmtGlobals *espGlobals = stmtGlobals->castToExEspStmtGlobals();
    if (espGlobals && espGlobals->getStmtStats())
      parentQid = espGlobals->getStmtStats()->getQueryId();
  }
  ExeCliInterface cliInterface(getHeap(), NULL, NULL, parentQid);
  while (1)
    {
      switch (step_)
	{
	case INITIAL_:
	  {
           
            if (getLItdb().inputExpr())
              {
                step_ = EVAL_INPUT_;
                break;
              }

            strcpy(tableName_, getLItdb().getTableName());

	    step_ = COLLECT_LOBINFO_;
	  }
	break;

        case EVAL_INPUT_:
          {
	    workAtp_->getTupp(getLItdb().workAtpIndex())
	      .setDataPointer(inputNameBuf_);

	    ex_expr::exp_return_type exprRetCode =
	      getLItdb().inputExpr()->eval(pentry_down->getAtp(), workAtp_);
	    if (exprRetCode == ex_expr::EXPR_ERROR)
	      {
		step_ = HANDLE_ERROR_;
		break;
	      }

            short len = *(short*)inputNameBuf_;
            str_cpy_all(tableName_, &inputNameBuf_[2], len);
            tableName_[len] = 0;

            step_ = COLLECT_LOBINFO_;
          }
          break;

        case COLLECT_LOBINFO_:
          {
            if (currLobNum_ == getLItdb().getNumLobs()+1)
              {
                step_ = DONE_;
                break;
              }
            if (collectLobInfo(tableName_,currLobNum_, currContext))
              {
                step_ = HANDLE_ERROR_;
                break;
              }

            step_ = POPULATE_LOBINFO_BUF_;
          }
          break;

	case POPULATE_LOBINFO_BUF_:
	  {
            
            
            if (populateLobInfo(currLobNum_))
              {
                step_ = HANDLE_ERROR_;
                break;
                }

	    step_ = RETURN_LOBINFO_BUF_;
	  }
	break;

	case RETURN_LOBINFO_BUF_:
	  {
	    if (qparent_.up->isFull())
	      return WORK_OK;

	    short rc = 0;
	    if (moveRowToUpQueue((char*)lobInfo_, lobInfoBufLen_, &rc, FALSE))
	      return rc;

            currLobNum_++;

            step_ = COLLECT_LOBINFO_;
	  }
	break;

	case HANDLE_ERROR_:
	  {
	    retcode = handleError();
	    if (retcode == 1)
	      return WORK_OK;
	    
	    step_ = DONE_;
	  }
	break;
	
	case DONE_:
	  {
	    retcode = handleDone();
	    if (retcode == 1)
	      return WORK_OK;
	    
	    step_ = INITIAL_;
	    
	    return WORK_CALL_AGAIN;
	  }
	break;


	} // switch

    } // while

  return WORK_OK;
}
//LCOV_EXCL_STOP

We don't include HBASE?