/**
 * Copyright (c) 2021 OceanBase
 * OceanBase CE is licensed under Mulan PubL v2.
 * You can use this software according to the terms and conditions of the Mulan PubL v2.
 * You may obtain a copy of Mulan PubL v2 at:
 *          http://license.coscl.org.cn/MulanPubL-2.0
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 * See the Mulan PubL v2 for more details.
 */

#include <gtest/gtest.h>
#include "common/object/ob_object.h"
#include "common/row/ob_row.h"
#include "sql/ob_sql_init.h"
#include "sql/engine/expr/ob_sql_expression.h"
#include "sql/engine/ob_phy_operator.h"
#include "sql/engine/ob_single_child_phy_operator.h"
#include "sql/engine/ob_no_children_phy_operator.h"
#include "sql/engine/ob_physical_plan.h"
#include "sql/engine/aggregate/ob_merge_groupby.h"
#include "sql/engine/ob_exec_context.h"
#include "sql/session/ob_sql_session_info.h"

using namespace oceanbase;
using namespace oceanbase::sql;
using namespace oceanbase::common;
using namespace ::testing;
class MockSqlExpression : public common::ObDLinkBase<ObSqlExpression>
{
public:
  static ObSqlExpression *alloc();
  static void free(ObSqlExpression *ptr);
protected:
  friend class ::ObAggregateFunctionTest;
  // data members
  ObPostfixExpression post_expr_;
};
typedef common::ObGlobalFactory<MockSqlExpression, 1, common::ObModIds::OB_SQL_EXPR>
MockSqlExpressionFactory;
typedef common::ObTCFactory < MockSqlExpression, 1, common::ObModIds::OB_SQL_EXPR, 1 << 24,
                                                                                    8192 > MockSqlExpressionTCFactory;
inline MockSqlExpression *MockSqlExpression::alloc()
{
  return MockSqlExpressionTCFactory::get_instance()->get(MockSqlExpression::EXPR_TYPE_SQL);
}

inline void MockSqlExpression::free(MockSqlExpression *expr)
{
  if (OB_LIKELY(expr)) {
    expr->prev_ = expr->next_ = NULL;
  }
  MockSqlExpressionTCFactory::get_instance()->put(expr);
}

class mockPhysicalPlan
{
public:
  mockPhysicalPlan() {}
  ~mockPhysicalPlan() {}
  int destory()
  {
    int ret = OB_SUCCESS;
    DLIST_FOREACH(node, sql_expression_) {
      MockSqlExpression::free(node);
    }
    return ret;
  }
  int store_sql_expresion(MockSqlExpression *sql)
  {
    return sql_expression_.add_last(sql);
  }
private:
  ObDList<MockSqlExpression> sql_expression_;
};
class ObPhyOperatorTest: public ::testing::Test
{
public:
  ObPhyOperatorTest();
  virtual ~ObPhyOperatorTest();
  virtual void SetUp();
  virtual void TearDown();

private:
  // disallow copy
  ObPhyOperatorTest(const ObPhyOperatorTest &other);
  ObPhyOperatorTest& operator=(const ObPhyOperatorTest &other);
private:
  // data members
};
ObPhyOperatorTest::ObPhyOperatorTest()
{
}

ObPhyOperatorTest::~ObPhyOperatorTest()
{
}

void ObPhyOperatorTest::SetUp()
{
}

void ObPhyOperatorTest::TearDown()
{
}

TEST_F(ObPhyOperatorTest, physical_plan_size)
{
  typedef oceanbase::common::ObFixedArray<ObPhysicalPlan::ObTableVersion, common::ObIAllocator> BaseTableStore;
  typedef oceanbase::common::ObFixedArray<ObPhysicalPlan::ObTableVersion, common::ObIAllocator> ViewTableStore;
  typedef oceanbase::common::ObFixedArray<common::ObField, common::ObIAllocator> ParamsFieldArray;
  typedef oceanbase::common::ObFixedArray<common::ObField, common::ObIAllocator> ColumnsFieldArray;
  struct MockPhysicalPlan
  {
    common::ObArenaAllocator inner_alloc_;
    common::ObArenaAllocator &allocator_;
    int64_t prepare_count_;
    volatile int64_t ref_count_;
    int64_t schema_version_;
    uint64_t plan_id_;
    int64_t hint_timeout_us_;
    ObPhyOperator *main_query_;
    BaseTableStore table_store_;
    ViewTableStore view_table_store_;
    int64_t param_count_;
    int64_t merged_version_;
    common::ObDList<ObSqlExpression> pre_calc_exprs_;
    common::ObFixedArray<ObParamInfo, common::ObIAllocator> params_info_;
    uint64_t signature_;
    ColumnsFieldArray field_columns_;
    ParamsFieldArray param_columns_;
    common::ObFixedArray<share::AutoincParam, common::ObIAllocator> autoinc_params_; //auto-incrment param
    share::schema::ObStmtNeedPrivs stmt_need_privs_;
    common::ObFixedArray<ObVarInfo, common::ObIAllocator> vars_;
    ObPhyOperatorFactory op_factory_;
    ObSqlExpressionFactory sql_expression_factory_;
    ObExprOperatorFactory expr_op_factory_;
    stmt::StmtType stmt_type_;
    stmt::StmtType literal_stmt_type_; // 含义参考ObBasicStmt中对应定义
    ObPhyPlanType plan_type_;
    common::ObConsistencyLevel hint_consistency_;
    uint32_t next_phy_operator_id_; //share val
    // for regexp expression's compilation
    int16_t regexp_op_count_;
    bool is_sfu_;
    bool fetch_cur_time_;
    bool is_contain_virtual_table_;//为虚拟表服务，如果判断出语句中涉及虚拟表
    bool is_require_sys_tenant_priv_;
    //if the stmt  contains user variable assignment
    //such as @a:=123
    //we may need to serialize the map to remote server
    bool is_contains_assignment_;
    bool affected_last_insert_id_; //不需要序列化远端，只在本地生成执行计划和open resultset的时候需要
    bool is_affect_found_row_; //not need serialize
  };

  printf("output mock physical plan = %ld, ModulePageAllocator=%ld\n", sizeof(MockPhysicalPlan), sizeof(ModulePageAllocator));
  ObPhysicalPlan plan;
  printf("output plan size=%ld\n", sizeof(plan));
  common::ObConsistencyLevel hint_consistency;
  printf("output enum size = %ld\n", sizeof(hint_consistency));
  common::ObDList<ObSqlExpression> sql_expression;
  printf("output dlist size=%ld\n", sizeof(sql_expression));
  //printf("output fixarray = %ld, IArray=%ld\n", sizeof(common::ObFixedArray), sizeof(common::ObIArray));
  printf("output IArray=%ld\n", sizeof(common::ObIArray<int>));
  printf("output fixarray = %ld\n", sizeof(common::ObFixedArray<int, common::ObArenaAllocator>));
  printf("output physical plan size=%ld\n", sizeof(ObPhysicalPlan));
  printf("output factory=%ld, sql_expression=%ld\n", sizeof(ObPhyOperatorFactory), sizeof(ObSqlExpression));
  printf("output sql_factory=%ld, expr_op=%ld\n", sizeof(ObSqlExpressionFactory), sizeof(ObExprOperatorFactory));
  common::ObArenaAllocator alloc;
  common::ObArenaAllocator &a = alloc;
  common::ObArenaAllocator *p = &alloc;
  printf("output referrence =%ld, Obiallocator=%ld\n", sizeof(common::ObArenaAllocator &), sizeof(common::ObIAllocator &));
  printf("output alloc =%ld, refference=%ld, point=%ld\n", sizeof(alloc), sizeof(a), sizeof(p));
  printf("output pramInfo before=%ld\n", sizeof(ObParamInfo));
  struct MockParamInfo
  {
    common::ObObjType type_;
    common::ObScale scale_;
    common::ObObjParam::ParamFlag flag_;
  };
  printf("output MockParamInfo after=%ld\n", sizeof(MockParamInfo));
  printf("output ObPostItem size before=%ld, obj=%ld\n", sizeof(ObPostExprItem),sizeof(common::ObObj));
  class MockPostExprItem
  {
    common::ObObj v1_;  // const
    union
    {
      int64_t query_id_;
      int64_t cell_index_;  // column reference, aka cell index in ObRow
      ObExprOperator *op_;  // expression operator
      ObSetVar::SetScopeType sys_var_scope_;
    } v2_;
    common::ObAccuracy accuracy_;  // for const, column, questionmark
    ObItemType  item_type_;
  };
  printf("output MockPostItem size=%ld\n", sizeof(MockPostExprItem));
  printf("output ObSqlExpression size=%ld, ObPostfixExpression=%ld\n", sizeof(ObSqlExpression), sizeof(ObPostfixExpression));
  printf("output ObDList size=%ld, ObNode size=%ld\n", sizeof(ObDList<int>), sizeof(ObDLinkBase<int>));
  printf("output phy_operator =%ld", sizeof(ObPhyOperator));
  printf("start to test tc_factory");
  mockPhysicalPlan mock_plan;
  MockSqlExpression *sql1 = MockSqlExpression::alloc();
  MockSqlExpression *sql2 = MockSqlExpression::alloc();
  EXPECT_NE(NULL, sql1);
  EXPECT_NE(NULL, sql2);
  EXPECT_EQ(OB_SUCCESS, mock_plan.store_sql_expresion(sql1));
  EXPECT_EQ(OB_SUCCESS, mock_plan.store_sql_expresion(sql2));
  mock_plan.destory();
}
int main(int argc, char **argv)
{
  init_sql_factories();
  ::testing::InitGoogleTest(&argc,argv);
  return RUN_ALL_TESTS();
}