#pragma once

#ifndef APACHE_GEODE_GUARD_f57a1f9a1b1286d041f077ee231e8637
#define APACHE_GEODE_GUARD_f57a1f9a1b1286d041f077ee231e8637

/*
 * 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.
 */

#include <gfcpp/GeodeCppCache.hpp>
#include <stdlib.h>
#include <gfcpp/SystemProperties.hpp>
#include <ace/OS.h>

#include "DistributedSystemImpl.hpp"

#include "../testobject/Portfolio.hpp"
#include "../testobject/Position.hpp"
#include "../testobject/PdxType.hpp"
#include "../testobject/PortfolioPdx.hpp"
#include "../testobject/PositionPdx.hpp"
#include "../pdxautoserializerclass/PortfolioPdx.hpp"
#include "../pdxautoserializerclass/PositionPdx.hpp"
#include "fwklib/FwkLog.hpp"

#include <gfcpp/ResultSet.hpp>
#include <gfcpp/StructSet.hpp>

#ifndef ROOT_SCOPE
#define ROOT_SCOPE LOCAL
#endif

using namespace apache::geode::client;
using namespace PdxTests;
using namespace AutoPdxTests;

namespace testData {

const int RS_ARRAY_SIZE = 41;
const int SS_ARRAY_SIZE = 35;
const int CQRS_ARRAY_SIZE = 24;
const int RSP_ARRAY_SIZE = 13;
const int SSP_ARRAY_SIZE = 17;

const int MAX_QRY_LENGTH = 512;
enum queryCategory {
  singleRegion = 1,
  multiRegion,
  operators,
  constants,
  functions,
  collectionOps,
  keywords,
  regionInterface,
  nestedQueries,
  importAndSelect,
  canonicalization,
  unsupported,
  queryAndIndexing,
  misc,
  qcEnd /*to mark the end of enum*/
} qcType;

class QueryStrings {
 public:
  QueryStrings(queryCategory pcategory, const char* pquery,
               bool pisLargeResultset = false) {
    int32_t querylen = static_cast<int32_t>(strlen(pquery));
    if (querylen < MAX_QRY_LENGTH) memcpy(_query, pquery, querylen);
    memset(&_query[querylen], '\0', 1);
    category = pcategory;
    haveLargeResultset = pisLargeResultset;
  }

  static int RSsize() { return RS_ARRAY_SIZE; };
  static int SSsize() { return SS_ARRAY_SIZE; };
  static int CQRSsize() { return CQRS_ARRAY_SIZE; };
  static int RSPsize() { return RSP_ARRAY_SIZE; };
  static int SSPsize() { return SSP_ARRAY_SIZE; };

  const char* query() const { return _query; };

 public:
  char _query[MAX_QRY_LENGTH];
  queryCategory category;
  bool haveLargeResultset;

 private:
  QueryStrings();
  QueryStrings* operator=(QueryStrings&);
};

#define QRY(category, query) QueryStrings(category, query)

// for large resultset
#define LQRY(category, query) QueryStrings(category, query, true)

const QueryStrings resultsetQueries[RS_ARRAY_SIZE] = {
    // 0 idx
    QRY(singleRegion, "select distinct * from /Portfolios port"),
    QRY(singleRegion, "select distinct pkid from /Portfolios"),
    LQRY(singleRegion,
         "select distinct port from /Portfolios port, "
         "port.Positions.values"),
    QRY(singleRegion,
        "select distinct pf from /Portfolios pf , pf.positions.values "
        "pos where pos.getSecId = 'IBM' and NOT pf.isActive")

    // 4 idx
    ,
    LQRY(multiRegion,
         "Select distinct pf from /Portfolios pf, /Portfolios2, "
         "/Portfolios3 where pf.isActive = TRUE"),
    LQRY(multiRegion,
         "select distinct pos from /Portfolios, /Portfolios/Positions "
         "pos"),
    LQRY(multiRegion,
         "select distinct port from /Portfolios port , /Positions pos "
         "where pos.getSecId in (select distinct pos.getSecId from "
         "port.positions.values pos)")

    // 6 idx
    ,
    QRY(operators, "select distinct * from /Portfolios where ID =  2"),
    QRY(operators, "select distinct * from /Portfolios where ID != 2")

    // 9 idx
    ,
    QRY(constants, "select distinct * from /Portfolios where ID = NULL"),
    QRY(constants, "select distinct * from /Portfolios where ID = UNDEFINED"),
    QRY(constants, "select distinct * from /Portfolios where NULL"),
    QRY(constants, "select distinct * from /Portfolios where UNDEFINED"),
    QRY(constants, "select distinct * from /Portfolios where TRUE"),
    QRY(constants, "select distinct * from /Portfolios where 1=1"),
    QRY(constants, "select distinct * from /Portfolios where 'a'<>'a'"),
    QRY(constants,
        "select distinct port from /Portfolios port, "
        "port.Positions.values where FALSE"),
    QRY(constants,
        "select distinct port from /Portfolios port, "
        "port.Positions.values where UNDEFINED = 1"),
    QRY(constants,
        "select distinct port from /Portfolios port where "
        "IS_UNDEFINED(UNDEFINED)")

    // 19 idx
    ,
    QRY(functions,
        "select distinct * from /Portfolios port where "
        "IS_DEFINED(TRUE)"),
    QRY(functions,
        "select distinct * from /Portfolios port where "
        "IS_UNDEFINED(ID)"),
    LQRY(nestedQueries,
         "select distinct this.value from /Portfolios.entrySet this "
         "where element(select distinct * from /Portfolios.keySet p_k "
         "where p_k = this.key ) = 'port1-3' and this.value.status = "
         "'inactive'"),
    QRY(functions, "select distinct nvl(NULL, 'foundNull') from /Portfolios")
    //, QRY(functions   , "select distinct nvl('notNull', 'foundNull')
    //= 'notNull' from /Portfolios" )
    ,
    QRY(functions,
        "select distinct nvl('notNull', 'foundNull') from /Portfolios"),
    QRY(functions,
        "select distinct * from /Portfolios pf where "
        "nvl(pf.position2,'foundNull') = 'foundNull'"),
    QRY(functions,
        "select distinct nvl(pf.position2, 'inProjection') from "
        "/Portfolios pf where nvl(pf.position2,'foundNull') = "
        "'foundNull'")  // constant

    // 26 idx
    ,
    QRY(regionInterface,
        "select distinct * from /Portfolios.keys where toString = "
        "'port1-1'")  // constant
    ,
    QRY(regionInterface,
        "select distinct * from /Portfolios.values where ID = 1"),
    QRY(regionInterface,
        "select distinct value from /Portfolios.entries where value.ID "
        "= 1 and key = 'port1-1'")  // constant
    ,
    LQRY(regionInterface,
         "select distinct * from /Portfolios.keySet where toString = "
         "'port1-1'")  // constant
    ,
    LQRY(regionInterface,
         "select distinct key from /Portfolios.entrySet , "
         "value.positions.values   where value.ID = 1 and key = "
         "'port1-1'")  // constant

    // 31 idx
    ,
    QRY(functions,
        "select distinct * from /Portfolios WHERE NOT(SELECT DISTINCT "
        "* FROM positions.values p WHERE p.secId = 'IBM').isEmpty"),
    LQRY(nestedQueries,
         "select distinct x.value from /Portfolios.entrySet x where "
         "x.value.status = ELEMENT(select distinct p.value from "
         "/Portfolios.entrySet p where x.key = p.key).status"),
    LQRY(nestedQueries,
         "select distinct * from /Portfolios x where status = "
         "ELEMENT(select distinct p_k.value from /Portfolios.entrySet "
         "p_k where p_k.key = 'port1-1').status"),
    LQRY(nestedQueries,
         "select distinct p from /Portfolios p, (select distinct * "
         "from /Portfolios x, x.positions as myPos) where "
         "myPos.value.secId = 'YHOO'")

    // 35 idx
    ,
    LQRY(importAndSelect,
         "import javaobject.Position;"
         " select distinct secId FROM /Portfolios,  positions.values "
         "pos TYPE Position WHERE ID > 0 ")

    // 36 idx
    ,
    QRY(unsupported,
        "element(select distinct * from /Portfolios where ID "
        "<=3).status"),
    QRY(unsupported,
        "select distinct * from /Portfolios.subregions(false) where "
        "remove('5')!= null")
    //, QRY(unsupported, "element(select distinct * from /Portfolios
    // where ID =1).status")
    ,
    QRY(unsupported, "select distinct * from NULL"),
    QRY(unsupported, "select distinct * from UNDEFINED"),
    LQRY(misc,
         "select distinct * from /Portfolios WHERE NOT (select "
         "distinct * from positions.values p WHERE p.secId = "
         "'IBM').isEmpty")};  // end of resultsetQueries

const int resultsetRowCounts[RS_ARRAY_SIZE] = {
    20, 20, 20, 1,  10, 20, 20, 1, 19, 0, 0, 0,  0,  20, 20, 0, 0, 0, 20, 20, 0,
    1,  1,  1,  10, 1,  1,  1,  1, 1,  1, 2, 20, 10, 20, 10, 0, 0, 0, 0,  2};

const int constantExpectedRowsRS[10] = {1, 21, 22, 23, 25, 26, 28, 29, 30, 35};

const QueryStrings resultsetparamQueries[RSP_ARRAY_SIZE] = {
    // 0 idx
    QRY(operators, "select distinct * from /Portfolios where ID =  $1"),
    QRY(operators, "select distinct * from /Portfolios where ID != $1")

    // 2 idx
    ,
    QRY(constants, "select distinct * from /Portfolios where $1=$2"),
    QRY(constants, "select distinct * from /Portfolios where $1<>$2"),
    QRY(constants,
        "select distinct port from /Portfolios port, port.Positions.values "
        "where UNDEFINED = $1")

    // 5 idx
    ,
    LQRY(functions,
         "select distinct this.value from /Portfolios.entrySet this where "
         "element(select distinct * from /Portfolios.keySet p_k where p_k = "
         "this.key ) = $1 and this.value.status = $2"),
    QRY(functions,
        "select distinct * from /Portfolios pf where nvl(pf.position2,$1) = "
        "$2"),
    QRY(functions,
        "select distinct nvl(pf.position2, $1) from /Portfolios pf where "
        "nvl(pf.position2,$2) = $3")

    // 8 idx
    ,
    QRY(regionInterface,
        "select distinct * from /Portfolios.keys where toString = $1"),
    QRY(regionInterface,
        "select distinct * from /Portfolios.values where ID = $1"),
    QRY(regionInterface,
        "select distinct value from /Portfolios.entries where value.ID = $1 "
        "and key = $2"),
    LQRY(regionInterface,
         "select distinct * from /Portfolios.keySet where toString = $1"),
    LQRY(regionInterface,
         "select distinct key from /Portfolios.entrySet , "
         "value.positions.values   where value.ID = $1 and key = $2")};

const int noofQueryParam[] = {1, 1, 2, 2, 1, 2, 2, 3, 1, 1, 2, 1, 2};

const char queryparamSet[13][3][15] = {
    {"2"},
    {"2"},
    {"1", "1"},
    {"a", "a"},
    {"1"},
    {"port1-3", "inactive"},
    {"foundNull", "foundNull"},
    {"inProjection", "foundNull", "foundNull"},
    {"port1-1"},
    {"1"},
    {"1", "port1-1"},
    {"port1-1"},
    {"1", "port1-1"}};

const int resultsetRowCountsPQ[RSP_ARRAY_SIZE] = {1, 19, 20, 0, 0, 1, 10,
                                                  1, 1,  1,  1, 1, 1};

const int constantExpectedRowsPQRS[6] = {5, 7, 8, 10, 11, 12};

const QueryStrings structsetQueries[SS_ARRAY_SIZE] = {
    // 0 idx
    QRY(singleRegion,
        "select distinct ID, pkid, position1, position2, getType, status "
        "from /Portfolios")

    // 1 idx
    ,
    QRY(multiRegion,
        "select distinct ptf,pos from (select distinct * from /Portfolios "
        "ptf, positions.values pos) outp where outp.pos.secId = 'IBM'"),
    QRY(multiRegion,
        "select distinct ptf,pos from (select distinct * from ptf IN "
        "/Portfolios, pos IN positions.values) where pos.secId = 'IBM'")
    // to be enabled, QRY(multiRegion , "select distinct * from (select
    // distinct ptf.ID, pos AS myPos from /Portfolios ptf, positions.values
    // pos) ")
    /*to be removed */,
    QRY(multiRegion,
        "select distinct myPos, ID from (select distinct pos AS myPos, "
        "ptf.ID as ID from /Portfolios ptf, positions.values pos) ")
    // need to see later , QRY(multiRegion , "select distinct * from (select
    // distinct * from /Portfolios ptf, positions pos) p where
    // p.get('pos').value.secId = 'IBM'")
    ,
    QRY(multiRegion,
        "select distinct secId, getSharesOutstanding from /Positions")

    // 5 idx
    ,
    QRY(constants,
        "select distinct id, positions from /Portfolios where ID = NULL"),
    QRY(constants,
        "select distinct pkid, getPk() from /Portfolios where ID = "
        "UNDEFINED"),
    QRY(constants,
        "select distinct getPositions, getPositions from /Portfolios where "
        "TRUE"),
    QRY(constants,
        "select distinct id, status from /Portfolios where UNDEFINED"),
    QRY(constants,
        "select distinct getPositions, ID, status, pkid from /Portfolios "
        "where TRUE"),
    QRY(constants,
        "select distinct ID, pkid, getType from /Portfolios where 1=1"),
    QRY(constants,
        "select distinct ID, pkid, names from /Portfolios where 'a'<>'a'"),
    QRY(constants,
        "select distinct port.ID, port.status, port.names from /Portfolios "
        "port, port.Positions.values where TRUE"),
    QRY(constants,
        "select distinct port.ID, port.pkid, port.names from /Portfolios "
        "port, port.Positions.values where UNDEFINED = 1"),
    QRY(constants,
        "select distinct port.ID, port.pkid, port.getType from /Portfolios "
        "port where IS_UNDEFINED(UNDEFINED)")

    // 15 idx
    ,
    QRY(functions,
        "select distinct port.ID, port.status from /Portfolios port where "
        "IS_DEFINED(TRUE)"),
    QRY(functions,
        "select distinct port.ID, port.status from /Portfolios port where "
        "IS_UNDEFINED(ID)"),
    LQRY(nestedQueries,
         "select distinct oP.ID, oP.status, oP.getType from /Portfolios oP "
         "where element(select distinct p.ID, p.status, p.getType from "
         "/Portfolios p where p.ID = oP.ID).status = 'inactive'"),
    QRY(functions,
        "select distinct nvl(NULL, 'foundNull')='foundNull', 'dummy Col' "
        "from /Portfolios"),
    QRY(functions,
        "select distinct nvl('notNull', 'foundNull') as NtNul , 'dummy "
        "Col' as Dumbo from /Portfolios"),
    QRY(functions,
        "select distinct pf.ID, pf.status, pf.getType from /Portfolios pf "
        "where nvl(pf.position2,'foundNull') = 'foundNull'"),
    QRY(functions,
        "select distinct nvl(pf.position2, 'inProjection'), 'dummy Col' "
        "from /Portfolios pf where nvl(pf.position2,'foundNull') = "
        "'foundNull'")

    // 22 idx
    ,
    LQRY(nestedQueries,
         "select distinct keys, v.key, v.value.ID, v.value.toString from "
         "/Portfolios.keys keys, /Portfolios.entrySet v where "
         "v.value.toString in (select distinct p.toString from /Portfolios "
         "p where p.ID = v.value.ID) and keys = v.key"),
    LQRY(regionInterface,
         "select distinct ID, pkid, names, position2.secId from "
         "/Portfolios.values where nvl(position2,'nopes') != 'nopes' and "
         "ID > 1"),
    QRY(regionInterface,
        "select distinct key, value.ID, value.pkid from "
        "/Portfolios.entries where value.ID = 1 and key in Set('port1-1')"),
    LQRY(regionInterface,
         "select distinct key, secType, secId, underlyer, cnt from "
         "/Portfolios.entrySet , value.positions.values   where value.ID = "
         "10 and key = 'port1-10'"),
    LQRY(nestedQueries,
         "select distinct k, value.ID, value from /Portfolios.keySet k, "
         "(select distinct value from /Portfolios.entrySet) value where "
         "k.toString = 'port1-1'")

    // 27 idx
    ,
    QRY(nestedQueries,
        "select distinct x.ID, x.status, x.getType, myPos.value.secType, "
        "myPos.value.secId as security from (select distinct * from "
        "/Portfolios x, x.positions as myPos)"),
    LQRY(nestedQueries,
         "select distinct derivedProjAttrbts, key: p.key, id: p.value.ID  "
         "from /Portfolios.entries p, (select distinct x.ID, x.status, "
         "x.getType, myPos.secId from /Portfolios x, x.positions.values as "
         "myPos) derivedProjAttrbts where p.value.ID = "
         "derivedProjAttrbts.ID and derivedProjAttrbts.secId = 'IBM'"),
    LQRY(nestedQueries,
         "select distinct eP.key, eP.value from /Portfolios.entrySet eP, "
         "/Portfolios/Positions pos where pos.secId in (select distinct "
         "portPos.value.secId from (select distinct * from "
         "eP.value.positions) portPos)"),
    LQRY(nestedQueries,
         "select distinct pos.secId, pos.getSharesOutstanding from "
         "/Portfolios/Positions pos where pos.getSharesOutstanding in "
         "(select distinct inPos.getSharesOutstanding from /Positions "
         "inPos where inPos.secId = pos.secId)")

    // 31 idx
    //, QRY(canonicalization, "Select distinct pos.ID, security from
    /// Portfolios.getPositions pos, pos.secId security where length > 1 and
    // pos.ID > 0")
    ,
    QRY(canonicalization, "Select distinct ID, position1  from /Portfolios")

    // 32 idx
    ,
    QRY(unsupported,
        "select element(select distinct * from /Portfolios where ID "
        "<=1).status = 'active'"),
    QRY(unsupported,
        "select distinct * from /Portfolios.subregions(false) where "
        "remove('5')!= null"),
    LQRY(misc,
         "select distinct key: key, iD: entry.value.ID, secId: "
         "posnVal.secId  from /Portfolios.entries entry, "
         "entry.value.positions.values posnVal WHERE entry.value.getType = "
         "'type0' AND posnVal.secId = 'YHOO'")};  // end of structsetQueries

const int structsetRowCounts[SS_ARRAY_SIZE] = {
    20, 2, 2,  20, 20, 0, 0, 20, 0,  20, 20, 0,  20, 0,  20, 20, 0, 10,
    1,  1, 10, 1,  20, 9, 1, 1,  20, 20, 2,  20, 20, 20, 0,  1,  1};

const int structsetFieldCounts[SS_ARRAY_SIZE] = {
    6, 2, 2, 2, 2, 0, 0, 2, 0, 4, 3, 0, 3, 0, 3, 2, 0, 3,
    2, 2, 3, 2, 4, 4, 3, 5, 3, 5, 3, 2, 2, 2, 0, 3, 3};
const int constantExpectedRowsSS[16] = {4,  10, 12, 13, 14, 15, 17, 18,
                                        19, 20, 21, 23, 24, 25, 27, 30};

const QueryStrings structsetParamQueries[SSP_ARRAY_SIZE] = {
    // 0 idx
    QRY(multiRegion,
        "select distinct ptf,pos from (select distinct * from /Portfolios ptf, "
        "positions.values pos) outp where outp.pos.secId = $1")

    // 1 idx
    ,
    QRY(multiRegion,
        "select distinct ptf,pos from (select distinct * from ptf IN "
        "/Portfolios, pos IN positions.values) where pos.secId = $1"),
    QRY(constants,
        "select distinct ID, pkid, getType from /Portfolios where $1 = $2"),
    QRY(constants,
        "select distinct ID, pkid, names from /Portfolios where $1 <> $2")

    // 4 idx
    ,
    QRY(constants,
        "select distinct port.ID, port.pkid, port.names from /Portfolios port, "
        "port.Positions.values where UNDEFINED = $1"),
    LQRY(functions,
         "select distinct oP.ID, oP.status, oP.getType from /Portfolios oP "
         "where element(select distinct p.ID, p.status, p.getType from "
         "/Portfolios p where p.ID = oP.ID).status = $1"),
    QRY(functions,
        "select distinct nvl(NULL, $1)=$2, 'dummy Col' from /Portfolios"),
    QRY(functions,
        "select distinct nvl($1, $2) as NtNul , $3 as Dumbo from /Portfolios"),
    QRY(functions,
        "select distinct pf.ID, pf.status, pf.getType from /Portfolios pf "
        "where nvl(pf.position2,$1) = $2"),
    QRY(functions,
        "select distinct nvl(pf.position2, $1), $2 from /Portfolios pf where "
        "nvl(pf.position2, $3) = $4")

    // 10 idx
    ,
    LQRY(regionInterface,
         "select distinct ID, pkid, names, position2.secId from "
         "/Portfolios.values where nvl(position2, $1) != $1 and ID > $2"),
    QRY(regionInterface,
        "select distinct key, value.ID, value.pkid from /Portfolios.entries "
        "where value.ID = $1 and key in Set($2)"),
    LQRY(regionInterface,
         "select distinct key, secType, secId, underlyer, cnt from "
         "/Portfolios.entrySet , value.positions.values   where value.ID = $1 "
         "and key = $2"),
    LQRY(regionInterface,
         "select distinct k, value.ID, value from /Portfolios.keySet k, "
         "(select distinct value from /Portfolios.entrySet) value where "
         "k.toString = $1")

    // 14 idx
    ,
    LQRY(nestedQueries,
         "select distinct derivedProjAttrbts, key: p.key, id: p.value.ID  from "
         "/Portfolios.entries p, (select distinct x.ID, x.status, x.getType, "
         "myPos.secId from /Portfolios x, x.positions.values as myPos) "
         "derivedProjAttrbts where p.value.ID = derivedProjAttrbts.ID and "
         "derivedProjAttrbts.secId = $1"),
    QRY(unsupported,
        "select element(select distinct * from /Portfolios where ID <= "
        "$1).status = $2"),
    LQRY(misc,
         "select distinct key: key, iD: entry.value.ID, secId: posnVal.secId  "
         "from /Portfolios.entries entry, entry.value.positions.values posnVal "
         "WHERE entry.value.getType = $1 AND posnVal.secId = $2")};

const int numSSQueryParam[] = {1, 1, 2, 2, 1, 1, 2, 3, 2,
                               4, 2, 2, 2, 1, 1, 2, 2};

const char queryparamSetSS[17][4][15] = {
    {"IBM"},
    {"IBM"},
    {"1", "1"},
    {"a", "a"},
    {"1"},
    {"inactive"},
    {"foundNull", "foundNull"},
    {"notNull", "foundNull", "dummy Col"},
    {"foundNull", "foundNull"},
    {"inProjection", "dummy Col", "foundNull", "foundNull"},
    {"nopes", "1"},
    {"1", "port1-1"},
    {"10", "port1-10"},
    {"port1-1"},
    {"IBM"},
    {"1", "active"},
    {"type0", "YHOO"}};

const int structsetRowCountsPQ[SSP_ARRAY_SIZE] = {2, 2, 20, 0, 0,  10, 1, 1, 10,
                                                  1, 9, 1,  1, 20, 2,  0, 1};

const int structsetFieldCountsPQ[SSP_ARRAY_SIZE] = {2, 2, 3, 0, 0, 3, 2, 2, 3,
                                                    2, 4, 3, 5, 3, 3, 0, 3};

const int constantExpectedRowsSSPQ[10] = {2, 4, 5, 6, 7, 8, 9, 10, 11, 12};

const QueryStrings cqResultsetQueries[CQRS_ARRAY_SIZE] = {
    // 0 idx
    QRY(singleRegion, "select * from /Portfolios port")
    // 1 idx
    ,
    QRY(operators, "select  * from /Portfolios where ID =  2"),
    QRY(operators, "select  * from /Portfolios where ID != 2")

    // 3 idx
    ,
    QRY(constants, "select  * from /Portfolios where ID = NULL"),
    QRY(constants, "select  * from /Portfolios where ID = UNDEFINED"),
    QRY(constants, "select  * from /Portfolios where NULL"),
    QRY(constants, "select  * from /Portfolios where UNDEFINED"),
    QRY(constants, "select  * from /Portfolios where TRUE"),
    QRY(constants, "select  * from /Portfolios where 1=1"),
    QRY(constants, "select  * from /Portfolios where 'a'<>'a'")

    // 10 idx
    ,
    QRY(functions, "select  * from /Portfolios port where IS_DEFINED(TRUE)"),
    QRY(functions, "select  * from /Portfolios port where IS_UNDEFINED(ID)"),
    LQRY(nestedQueries,
         "select  this.value from /Portfolios.entrySet this where "
         "element(select  * from /Portfolios.keySet p_k where p_k = this.key ) "
         "= 'port1-3' and this.value.status = 'inactive'"),
    QRY(functions,
        "select  * from /Portfolios pf where nvl(pf.position2,'foundNull') = "
        "'foundNull'")

    // 14 idx
    ,
    QRY(functions,
        "select  * from /Portfolios WHERE NOT(SELECT DISTINCT * FROM "
        "positions.values p WHERE p.secId = 'IBM').isEmpty"),
    LQRY(nestedQueries,
         "select  x.value from /Portfolios.entrySet x where x.value.status = "
         "ELEMENT(select  p.value from /Portfolios.entrySet p where x.key = "
         "p.key).status"),
    LQRY(nestedQueries,
         "select  * from /Portfolios x where status = ELEMENT(select  "
         "p_k.value from /Portfolios.entrySet p_k where p_k.key = "
         "'port1-1').status"),
    LQRY(nestedQueries,
         "select  p from /Portfolios p, (select  * from /Portfolios x, "
         "x.positions as myPos) where myPos.value.secId = 'YHOO'")

    // 35 idx
    ,
    LQRY(importAndSelect,
         "import javaobject.Position;"
         " select  secId FROM /Portfolios,  positions.values pos TYPE Position "
         "WHERE ID > 0 ")

    // 36 idx
    ,
    QRY(unsupported, "element(select  * from /Portfolios where ID <=3).status"),
    QRY(unsupported,
        "select  * from /Portfolios.subregions(false) where remove('5')!= null")
    //, QRY(unsupported, "element(select  * from /Portfolios where ID
    //=1).status")
    ,
    QRY(unsupported, "select  * from NULL"),
    QRY(unsupported, "select  * from UNDEFINED"),
    LQRY(misc,
         "select  * from /Portfolios WHERE NOT (select  * from "
         "positions.values p WHERE p.secId = 'IBM').isEmpty")};

const int cqResultsetRowCounts[CQRS_ARRAY_SIZE] = {20, 1,  19, 0, 0, 0,  0, 20,
                                                   20, 0,  20, 0, 1, 10, 2, 20,
                                                   10, 20, 10, 0, 0, 0,  0, 2};

const int constantExpectedRowsCQRS[1] = {35};
}  // namespace testData
using namespace testData;
using namespace testobject;

class QueryHelper {
 public:
  static QueryHelper* singleton;

  static QueryHelper& getHelper() {
    if (singleton == NULL) {
      singleton = new QueryHelper();
    }
    return *singleton;
  }

  QueryHelper() {
    portfolioSetSize = 20;
    portfolioNumSets = 1;
    positionSetSize = 20;
    positionNumSets = 1;
  }

  virtual ~QueryHelper() { ; }

  virtual void populatePortfolioData(RegionPtr& pregion, int setSize,
                                     int numSets, int32_t objSize = 1);
  virtual void populatePortfolio(RegionPtr& rptr, int maxKey,
                                 int32_t objSize = 1);
  virtual void populatePositionData(RegionPtr& pregion, int setSize,
                                    int numSets);
  virtual void populatePortfolioPdxData(RegionPtr& pregion, int setSize,
                                        int numSets, int32_t objSize = 1,
                                        char** nm = NULL);
  virtual void populatePositionPdxData(RegionPtr& pregion, int setSize,
                                       int numSets);
  virtual void populateAutoPortfolioPdxData(RegionPtr& pregion, int setSize,
                                            int numSets, int32_t objSize = 1,
                                            char** nm = NULL);
  virtual void populateAutoPositionPdxData(RegionPtr& pregion, int setSize,
                                           int numSets);
  virtual void destroyPortfolioOrPositionData(RegionPtr& pregion, int setSize,
                                              int numSets,
                                              const char* dataType);
  virtual void invalidatePortfolioOrPositionData(RegionPtr& pregion,
                                                 int setSize, int numSets,
                                                 const char* dataType);

  // might need it in later.
  //  virtual void getRSQueryString(char category, int& queryIndex, std::string&
  //  query);
  //  virtual void getSSQueryString(char category, int& queryIndex, std::string&
  //  query);

  virtual bool verifyRS(SelectResultsPtr& resultset, int rowCount);
  virtual bool verifySS(SelectResultsPtr& structset, int rowCount,
                        int fieldCount);

  void populateRangePositionData(RegionPtr& rptr, int start, int end);
  bool compareTwoPositionObjects(SerializablePtr por1, SerializablePtr por2);
  SerializablePtr getExactPositionObject(int iForExactPosObject);
  void putExactPositionObject(RegionPtr& rptr, int iForExactPosObject);
  SerializablePtr getCachedPositionObject(RegionPtr& rptr,
                                          int iForExactPosObject);

  // utility methods
  virtual int getPortfolioSetSize() { return portfolioSetSize; };
  virtual int getPortfolioNumSets() { return portfolioNumSets; };
  virtual int getPositionSetSize() { return positionSetSize; };
  virtual int getPositionNumSets() { return positionNumSets; };

  bool isExpectedRowsConstantRS(int queryindex) {
    for (int i = (sizeof(constantExpectedRowsRS) / sizeof(int)) - 1; i > -1;
         i--) {
      if (constantExpectedRowsRS[i] == queryindex) {
        FWKINFO("index " << constantExpectedRowsRS[i]
                         << " is having constant rows ");
        return true;
      }
    }

    return false;
  }

  bool isExpectedRowsConstantSS(int queryindex) {
    for (int i = (sizeof(constantExpectedRowsSS) / sizeof(int)) - 1; i > -1;
         i--) {
      if (constantExpectedRowsSS[i] == queryindex) {
        FWKINFO("index " << constantExpectedRowsSS[i]
                         << " is having constant rows ");
        return true;
      }
    }

    return false;
  }

  bool isExpectedRowsConstantCQRS(int queryindex) {
    for (int i = (sizeof(constantExpectedRowsCQRS) / sizeof(int)) - 1; i > -1;
         i--) {
      if (constantExpectedRowsCQRS[i] == queryindex) {
        FWKINFO("index " << constantExpectedRowsCQRS[i]
                         << " is having constant rows ");
        return true;
      }
    }

    return false;
  }

  bool isExpectedRowsConstantPQRS(int queryindex) {
    for (int i = (sizeof(constantExpectedRowsPQRS) / sizeof(int)) - 1; i > -1;
         i--) {
      if (constantExpectedRowsPQRS[i] == queryindex) {
        printf("index %d is having constant rows \n",
               constantExpectedRowsPQRS[i]);
        return true;
      }
    }

    return false;
  }
  bool isExpectedRowsConstantSSPQ(int queryindex) {
    for (int i = (sizeof(constantExpectedRowsSSPQ) / sizeof(int)) - 1; i > -1;
         i--) {
      if (constantExpectedRowsSSPQ[i] == queryindex) {
        printf("index %d is having constant rows \n",
               constantExpectedRowsSSPQ[i]);
        return true;
      }
    }
    return false;
  }

 private:
  int portfolioSetSize;
  int portfolioNumSets;
  int positionSetSize;
  int positionNumSets;
  int32_t objectSize ATTR_UNUSED;
};

QueryHelper* QueryHelper::singleton = NULL;

//===========================================================================================

void QueryHelper::populateRangePositionData(RegionPtr& rptr, int start,
                                            int end) {
  for (int i = start; i <= end; i++) {
    CacheablePtr pos(new Position(i));
    char key[100];
    ACE_OS::sprintf(key, "pos%d", i);
    CacheableKeyPtr keyptr = CacheableKey::create(key);
    rptr->put(keyptr, pos);
  }
}

bool QueryHelper::compareTwoPositionObjects(SerializablePtr pos1,
                                            SerializablePtr pos2) {
  Position* p1 = dynamic_cast<Position*>(pos1.ptr());
  Position* p2 = dynamic_cast<Position*>(pos2.ptr());

  if (p1 == NULL || p2 == NULL) {
    printf("ERROR: The object(s) passed are not of Portflio type\n");
    return false;
  }

  DataOutput o1, o2;
  p1->toData(o1);
  p2->toData(o2);

  uint32_t len1 = o1.getBufferLength();
  uint32_t len2 = o2.getBufferLength();

  if (len1 != len2) {
    return false;
  }

  const uint8_t* ptr1 = o1.getBuffer();
  const uint8_t* ptr2 = o2.getBuffer();

  for (uint8_t i = 0; i < len1; i++) {
    if (*ptr1++ != *ptr2++) {
      return false;
    }
  }
  return true;
}

SerializablePtr QueryHelper::getExactPositionObject(int iForExactPosObject) {
  CacheablePtr pos(new Position(iForExactPosObject));
  return pos;
}

void QueryHelper::putExactPositionObject(RegionPtr& rptr,
                                         int iForExactPosObject) {
  char key[100];
  ACE_OS::sprintf(key, "pos%d", iForExactPosObject);
  CacheableKeyPtr keyptr = CacheableKey::create(key);
  CacheablePtr pos(new Position(iForExactPosObject));
  rptr->put(keyptr, pos);
}

SerializablePtr QueryHelper::getCachedPositionObject(RegionPtr& rptr,
                                                     int iForExactPosObject) {
  char key[100];
  ACE_OS::sprintf(key, "pos%d", iForExactPosObject);
  CacheableKeyPtr keyptr = CacheableKey::create(key);
  return rptr->get(keyptr);
}

//===========================================================================================

void QueryHelper::populatePortfolioData(RegionPtr& rptr, int setSize,
                                        int numSets, int32_t objSize) {
  // lets reset the counter for uniform population of position objects
  Position::resetCounter();
  CacheablePtr port;
  CacheableKeyPtr keyport;
  for (int set = 1; set <= numSets; set++) {
    for (int current = 1; current <= setSize; current++) {
      port = new Portfolio(current, objSize);

      char portname[100] = {0};
      ACE_OS::sprintf(portname, "port%d-%d", set, current);

      keyport = CacheableKey::create(portname);
      rptr->put(keyport, port);
    }
  }

  FWKINFO("all puts done \n");
}
void QueryHelper::populatePortfolio(RegionPtr& rptr, int maxKey,
                                    int32_t objSize) {
  // lets reset the counter for uniform population of position objects
  Position::resetCounter();
  CacheablePtr port;
  CacheableKeyPtr keyport;
  for (int current = 0; current <= maxKey; current++) {
    port = new Portfolio(current, objSize);

    char portname[1024] = {0};
    ACE_OS::sprintf(portname, "port%d-%d", current, current);

    keyport = CacheableKey::create(portname);
    rptr->put(keyport, port);
  }

  FWKINFO("All Portfolio puts done \n");
}

void QueryHelper::destroyPortfolioOrPositionData(RegionPtr& rptr, int setSize,
                                                 int numSets,
                                                 const char* dataType) {
  CacheableKeyPtr keyport;
  try {
    for (int set = 1; set <= numSets; set++) {
      for (int current = 1; current <= setSize; current++) {
        char portname[100] = {0};
        if (strcmp(dataType, "Portfolio") == 0 ||
            strcmp(dataType, "PortfolioPdx") == 0 ||
            strcmp(dataType, "AutoPortfolioPdx") == 0) {
          ACE_OS::sprintf(portname, "port%d-%d", set, current);
        } else if (strcmp(dataType, "Position") == 0 ||
                   strcmp(dataType, "PositionPdx") == 0 ||
                   strcmp(dataType, "AutoPositionPdx") == 0) {
          ACE_OS::sprintf(portname, "pos%d-%d", set, current);
        } else {
          throw apache::geode::client::IllegalArgumentException(
              "Unknown object type");
        }

        keyport = CacheableKey::create(portname);
        rptr->destroy(keyport);
      }
    }
  } catch (Exception& e) {
    FWKSEVERE("QueryHelper::destroyPortfolioOrPositionData Caught Exception: "
              << e.getMessage());
  }
  FWKINFO("destroy done \n");
}

void QueryHelper::invalidatePortfolioOrPositionData(RegionPtr& rptr,
                                                    int setSize, int numSets,
                                                    const char* dataType) {
  try {
    for (int set = 1; set <= numSets; set++) {
      for (int current = 1; current <= setSize; current++) {
        char portname[100] = {0};
        if (strcmp(dataType, "Portfolio") == 0) {
          ACE_OS::sprintf(portname, "port%d-%d", set, current);
        } else if (strcmp(dataType, "Position") == 0) {
          ACE_OS::sprintf(portname, "pos%d-%d", set, current);
        }

        CacheableKeyPtr keyport = CacheableKey::create(portname);
        rptr->invalidate(keyport);
      }
    }
  } catch (Exception& e) {
    FWKSEVERE(
        "QueryHelper::invalidatePortfolioOrPositionData Caught Exception: "
        << e.getMessage());
  }
  FWKINFO("Invalidation done \n");
}

const char* secIds[] = {"SUN", "IBM",  "YHOO", "GOOG", "MSFT",
                        "AOL", "APPL", "ORCL", "SAP",  "DELL"};

void QueryHelper::populatePositionData(RegionPtr& rptr, int setSize,
                                       int numSets) {
  int numSecIds = sizeof(secIds) / sizeof(char*);
  CacheableKeyPtr keypos;
  CacheablePtr pos;
  for (int set = 1; set <= numSets; set++) {
    for (int current = 1; current <= setSize; current++) {
      pos = new Position(secIds[current % numSecIds], current * 100);

      char posname[100] = {0};
      ACE_OS::sprintf(posname, "pos%d-%d", set, current);

      keypos = CacheableKey::create(posname);
      rptr->put(keypos, pos);
    }
  }
}

void QueryHelper::populatePortfolioPdxData(RegionPtr& rptr, int setSize,
                                           int numSets, int32_t objSize,
                                           char** nm) {
  // lets reset the counter for uniform population of position objects
  testobject::PositionPdx::resetCounter();

  for (int set = 1; set <= numSets; set++) {
    for (int current = 1; current <= setSize; current++) {
      CacheablePtr port(new testobject::PortfolioPdx(current, objSize));

      char portname[100] = {0};
      ACE_OS::sprintf(portname, "port%d-%d", set, current);

      CacheableKeyPtr keyport = CacheableKey::create(portname);

      rptr->put(keyport, port);
      LOGINFO("populatePortfolioPdxData:: Put for iteration current = %d done",
              current);
    }
  }
  // portfolioSetSize = setSize; portfolioNumSets = numSets; objectSize =
  // objSize;

  printf("all puts done \n");
}

void QueryHelper::populatePositionPdxData(RegionPtr& rptr, int setSize,
                                          int numSets) {
  int numSecIds = sizeof(secIds) / sizeof(char*);

  for (int set = 1; set <= numSets; set++) {
    for (int current = 1; current <= setSize; current++) {
      CacheablePtr pos(new testobject::PositionPdx(secIds[current % numSecIds],
                                                   current * 100));

      char posname[100] = {0};
      ACE_OS::sprintf(posname, "pos%d-%d", set, current);

      CacheableKeyPtr keypos = CacheableKey::create(posname);
      rptr->put(keypos, pos);
      LOGINFO("populatePositionPdxData:: Put for iteration current = %d done",
              current);
    }
  }
  // positionSetSize = setSize; positionNumSets = numSets;
}
void QueryHelper::populateAutoPortfolioPdxData(RegionPtr& rptr, int setSize,
                                               int numSets, int32_t objSize,
                                               char** nm) {
  // lets reset the counter for uniform population of position objects
  AutoPdxTests::PositionPdx::resetCounter();

  for (int set = 1; set <= numSets; set++) {
    for (int current = 1; current <= setSize; current++) {
      CacheablePtr port(new AutoPdxTests::PortfolioPdx(current, objSize));

      char portname[100] = {0};
      ACE_OS::sprintf(portname, "port%d-%d", set, current);

      CacheableKeyPtr keyport = CacheableKey::create(portname);

      rptr->put(keyport, port);
      LOGINFO(
          "populateAutoPortfolioPdxData:: Put for iteration current = %d done",
          current);
    }
  }
  // portfolioSetSize = setSize; portfolioNumSets = numSets; objectSize =
  // objSize;

  printf("all puts done \n");
}

void QueryHelper::populateAutoPositionPdxData(RegionPtr& rptr, int setSize,
                                              int numSets) {
  int numSecIds = sizeof(secIds) / sizeof(char*);

  for (int set = 1; set <= numSets; set++) {
    for (int current = 1; current <= setSize; current++) {
      CacheablePtr pos(new AutoPdxTests::PositionPdx(
          secIds[current % numSecIds], current * 100));

      char posname[100] = {0};
      ACE_OS::sprintf(posname, "pos%d-%d", set, current);

      CacheableKeyPtr keypos = CacheableKey::create(posname);
      rptr->put(keypos, pos);
      LOGINFO(
          "populateAutoPositionPdxData:: Put for iteration current = %d done",
          current);
    }
  }
  // positionSetSize = setSize; positionNumSets = numSets;
}
bool QueryHelper::verifyRS(SelectResultsPtr& resultSet, int expectedRows) {
  if (!instanceOf<ResultSetPtr>(resultSet)) {
    return false;
  }

  ResultSetPtr rsptr = staticCast<ResultSetPtr>(resultSet);

  int foundRows = 0;

  SelectResultsIterator iter = rsptr->getIterator();

  for (int32_t rows = 0; rows < rsptr->size(); rows++) {
    SerializablePtr ser = (*rsptr)[rows];  // iter.next();
    foundRows++;
  }

  FWKINFO("found rows " << foundRows << " expected " << expectedRows);
  if (foundRows == expectedRows) return true;

  return false;
}

bool QueryHelper::verifySS(SelectResultsPtr& structSet, int expectedRows,
                           int expectedFields) {
  FWKINFO("QueryHelper::verifySS : expectedRows = "
          << expectedRows << " ,expectedFields = " << expectedFields);

  if (!instanceOf<StructSetPtr>(structSet)) {
    if (expectedRows == 0 && expectedFields == 0) {
      return true;  // quite possible we got a null set back.
    }
    FWKINFO("we have structSet itself NULL");
    return false;
  }

  StructSetPtr ssptr = staticCast<StructSetPtr>(structSet);

  int foundRows = 0;

  SelectResultsIterator iter = ssptr->getIterator();

  for (int32_t rows = 0; rows < ssptr->size(); rows++) {
    SerializablePtr ser = (*ssptr)[rows];  // iter.next();
    foundRows++;

    Struct* siptr = dynamic_cast<Struct*>(ser.ptr());

    if (siptr == NULL) {
      LOGINFO("siptr is NULL \n\n");
      return false;
    }

    int foundFields = 0;

    for (int32_t cols = 0; cols < siptr->length(); cols++) {
      SerializablePtr field = (*siptr)[cols];  // siptr->next();
      foundFields++;
    }

    if (foundFields != expectedFields) {
      char buffer[1024] = {'\0'};
      sprintf(buffer, "found fields %d, expected fields %d \n", foundFields,
              expectedFields);
      FWKSEVERE(buffer);
      return false;
    }
  }

  if (foundRows == expectedRows) {
    FWKINFO("found rows " << foundRows << " expected " << expectedRows);
    return true;
  }

  // lets log and return in case of error only situation
  char buffer[1024] = {'\0'};
  sprintf(buffer, "found rows %d, expected rows %d\n", foundRows, expectedRows);
  FWKSEVERE(buffer);
  return false;
}


#endif // APACHE_GEODE_GUARD_f57a1f9a1b1286d041f077ee231e8637