/* Copyright (c) 2003-2005 MySQL AB
   Use is subject to license terms

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA */

#include <NdbApi.hpp>
#include <NdbOut.hpp>
#include <NdbMutex.h>

#include "TraceNdbApi.hpp"


int g_nParamTrace;
NdbMutex* g_pNdbMutexTrace = 0;


void TraceBegin(void)
{
  if(!g_pNdbMutexTrace)
  {
    g_pNdbMutexTrace = NdbMutex_Create();
  }
  NdbMutex_Lock(g_pNdbMutexTrace);
  g_nParamTrace = 0;
}

void TraceEnd(void)
{
  ndbout << endl;
  g_nParamTrace = 0;
  NdbMutex_Unlock(g_pNdbMutexTrace);
}

void TraceMethod(const char* szMethod)
{
  ndbout << "->" << szMethod << "(";
  g_nParamTrace = 0;
}

void TraceParamComma(void)
{
  if(g_nParamTrace)
  {
    ndbout << ", ";
  }
  ++g_nParamTrace;
}

void TraceNdb(Ndb* pNdb)
{
  TraceParamComma();
  ndbout << "((Ndb*)" << hex << (Uint32)pNdb << ")";
}

void TraceNdbSchemaCon(NdbSchemaCon* pNdbSchemaCon)
{
  TraceParamComma();
  ndbout << "((NdbSchemaCon*)" << hex << (Uint32)pNdbSchemaCon << ")";
}

void TraceNdbSchemaOp(NdbSchemaOp* pNdbSchemaOp)
{
  TraceParamComma();
  ndbout << "((NdbSchemaOp*)" << hex << (Uint32)pNdbSchemaOp << ")";
}

void TraceNdbConnection(const NdbConnection* pNdbConnection)
{
  TraceParamComma();
  ndbout << "((NdbConnection*)" << hex << (Uint32)pNdbConnection << ")";
}

void TraceNdbOperation(NdbOperation* pNdbOperation)
{
  TraceParamComma();
  ndbout << "((NdbOperation*)" << hex << (Uint32)pNdbOperation << ")";
}

void TraceNdbIndexOperation(NdbIndexOperation* pNdbIndexOperation)
{
  TraceParamComma();
  ndbout << "((NdbIndexOperation*)" << hex << (Uint32)pNdbIndexOperation << ")";
}

void TraceNdbRecAttr(NdbRecAttr* pNdbRecAttr)
{
  TraceParamComma();
  ndbout << "((NdbRecAttr*)" << hex << (Uint32)pNdbRecAttr << ")";
}

void TraceTable(Table* pTable)
{
  TraceParamComma();
  ndbout << "((Table*)" << hex << (Uint32)pTable << ")";
}

void TraceString(const char* szParam)
{
  TraceParamComma();
  ndbout << "\"" << szParam << "\"";
}

void TraceInt(const int i)
{
  TraceParamComma();
  ndbout << "(int)" << dec << i;
}

void TraceUint32(const Uint32 n)
{
  TraceParamComma();
  ndbout << "(Uint32)" << dec << n;
}

void TraceKeyType(const KeyType aKeyType)
{
  TraceParamComma();
  switch(aKeyType)
  {
  case Undefined: ndbout << "Undefined"; break;
  case NoKey: ndbout << "NoKey"; break;
  case TupleKey: ndbout << "TupleKey"; break;
  case TupleId: ndbout << "TupleId"; break;
  default:  ndbout << "(KeyType)" << aKeyType; break;
  }
}

void TraceExecType(const ExecType aExecType)
{
  switch(aExecType)
  {
  case NoExecTypeDef: ndbout << "NoExecTypeDef"; break;
  case Prepare: ndbout << "Prepare"; break;
  case NoCommit: ndbout << "NoCommit"; break;
  case Commit: ndbout << "Commit"; break;
  case Rollback: ndbout << "Rollback"; break;
  default: ndbout << "(ExecType)" << aExecType; break;
  }
}


void TraceNdbError(const NdbError& err)
{
  TraceParamComma();
  ndbout << "(NdbError)" << err;
}



void TraceVoid(void)
{
  ndbout << "void";
}

void TraceReturn(void)
{
  ndbout << "); // return ";
  g_nParamTrace = 0;
}


// TraceNdbSchemaOp

int CTraceNdbSchemaOp::createTable(const char* aTableName)
{
  int i = NdbSchemaOp::createTable(aTableName);
  TraceBegin();
  TraceNdbSchemaOp(this);
  TraceMethod("createTable");
  TraceString(aTableName);
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}

int CTraceNdbSchemaOp::createAttribute(const char* aAttrName, KeyType aTupleyKey)
{
  int i = NdbSchemaOp::createAttribute(aAttrName, aTupleyKey);
  TraceBegin();
  TraceNdbSchemaOp(this);
  TraceMethod("createAttribute");
  TraceString(aAttrName);
  TraceKeyType(aTupleyKey);
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}



// TraceNdbSchemaCon

CTraceNdbSchemaOp* CTraceNdbSchemaCon::getNdbSchemaOp()
{ 
  NdbSchemaOp* pNdbSchemaOp = NdbSchemaCon::getNdbSchemaOp();
  TraceBegin();
  TraceNdbSchemaCon(this);
  TraceMethod("getNdbSchemaOp");
  TraceReturn();
  TraceNdbSchemaOp(pNdbSchemaOp);
  TraceEnd();
  return (CTraceNdbSchemaOp*)pNdbSchemaOp; 
}

int CTraceNdbSchemaCon::execute()
{
  int i = NdbSchemaCon::execute();
  TraceBegin();
  TraceNdbSchemaCon(this);
  TraceMethod("execute");
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}



// TraceNdbRecAttr

Uint32 CTraceNdbRecAttr::u_32_value()
{
  Uint32 n = NdbRecAttr::u_32_value();
  TraceBegin();
  TraceNdbRecAttr(this);
  TraceMethod("u_32_value");
  TraceReturn();
  TraceUint32(n);
  TraceEnd();
  return n;
}



// TraceNdbOperation

int CTraceNdbOperation::insertTuple()
{
  int i = NdbOperation::insertTuple();
  TraceBegin();
  TraceNdbOperation(this);
  TraceMethod("insertTuple");
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}

int CTraceNdbOperation::updateTuple()
{
  int i = NdbOperation::updateTuple();
  TraceBegin();
  TraceNdbOperation(this);
  TraceMethod("updateTuple");
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}

int CTraceNdbOperation::interpretedUpdateTuple()
{
  int i = NdbOperation::interpretedUpdateTuple();
  TraceBegin();
  TraceNdbOperation(this);
  TraceMethod("interpretedUpdateTuple");
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}

int CTraceNdbOperation::readTuple()
{
  int i = NdbOperation::readTuple();
  TraceBegin();
  TraceNdbOperation(this);
  TraceMethod("readTuple");
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}


int CTraceNdbOperation::readTupleExclusive()
{
  int i = NdbOperation::readTupleExclusive();
  TraceBegin();
  TraceNdbOperation(this);
  TraceMethod("readTupleExclusive");
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}


int CTraceNdbOperation::deleteTuple()
{
  int i = NdbOperation::deleteTuple();
  TraceBegin();
  TraceNdbOperation(this);
  TraceMethod("deleteTuple");
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}

int CTraceNdbOperation::equal(const char* anAttrName, Uint32 aValue)
{
  int i = NdbOperation::equal(anAttrName, aValue);
  TraceBegin();
  TraceNdbOperation(this);
  TraceMethod("equal");
  TraceString(anAttrName);
  TraceUint32(aValue);
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}

int CTraceNdbOperation::setValue(const char* anAttrName, Uint32 aValue)
{
  int i = NdbOperation::setValue(anAttrName, aValue);
  TraceBegin();
  TraceNdbOperation(this);
  TraceMethod("setValue");
  TraceString(anAttrName);
  TraceUint32(aValue);
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}

int CTraceNdbOperation::incValue(const char* anAttrName, Uint32 aValue)
{
  int i = NdbOperation::incValue(anAttrName, aValue);
  TraceBegin();
  TraceNdbOperation(this);
  TraceMethod("incValue");
  TraceString(anAttrName);
  TraceUint32(aValue);
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}

CTraceNdbRecAttr* CTraceNdbOperation::getValue(const char* anAttrName)
{
  NdbRecAttr* pNdbRecAttr = NdbOperation::getValue(anAttrName);
  TraceBegin();
  TraceNdbOperation(this);
  TraceMethod("getValue");
  TraceString(anAttrName);
  TraceReturn();
  TraceNdbRecAttr(pNdbRecAttr);
  TraceEnd();
  return (CTraceNdbRecAttr*)pNdbRecAttr;
}


// TraceNdbIndexOperation

int CTraceNdbIndexOperation::equal(const char* anAttrName, Uint32 aValue)
{
  int i = NdbIndexOperation::equal(anAttrName, aValue);
  TraceBegin();
  TraceNdbIndexOperation(this);
  TraceMethod("equal");
  TraceString(anAttrName);
  TraceUint32(aValue);
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}


int CTraceNdbIndexOperation::incValue(const char* anAttrName, Uint32 aValue)
{
  int i = NdbIndexOperation::incValue(anAttrName, aValue);
  TraceBegin();
  TraceNdbIndexOperation(this);
  TraceMethod("incValue");
  TraceString(anAttrName);
  TraceUint32(aValue);
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}


CTraceNdbRecAttr* CTraceNdbIndexOperation::getValue(const char* anAttrName)
{
  NdbRecAttr* pNdbRecAttr = NdbIndexOperation::getValue(anAttrName);
  TraceBegin();
  TraceNdbIndexOperation(this);
  TraceMethod("getValue");
  TraceString(anAttrName);
  TraceReturn();
  TraceNdbRecAttr(pNdbRecAttr);
  TraceEnd();
  return (CTraceNdbRecAttr*)pNdbRecAttr;
}


// TraceNdbConnection

CTraceNdbOperation* CTraceNdbConnection::getNdbOperation(const char* aTableName)
{
  NdbOperation* pNdbOperation = NdbConnection::getNdbOperation(aTableName);
  TraceBegin();
  TraceNdbConnection(this);
  TraceMethod("getNdbOperation");
  TraceString(aTableName);
  TraceReturn();
  TraceNdbOperation(pNdbOperation);
  TraceEnd();
  return (CTraceNdbOperation*)pNdbOperation; 
}

CTraceNdbIndexOperation* CTraceNdbConnection::getNdbIndexOperation(const char* anIndexName, const char* aTableName)
{
  NdbIndexOperation* pNdbIndexOperation = NdbConnection::getNdbIndexOperation(anIndexName, aTableName);
  TraceBegin();
  TraceNdbConnection(this);
  TraceMethod("getNdbIndexOperation");
  TraceString(anIndexName);
  TraceString(aTableName);
  TraceReturn();
  TraceNdbIndexOperation(pNdbIndexOperation);
  TraceEnd();
  return (CTraceNdbIndexOperation*)pNdbIndexOperation; 
}

int CTraceNdbConnection::execute(ExecType aTypeOfExec)
{
  int i = NdbConnection::execute(aTypeOfExec);
  TraceBegin();
  TraceNdbConnection(this);
  TraceMethod("execute");
  TraceExecType(aTypeOfExec);
  TraceReturn();
  TraceInt(i);
  TraceEnd();
  return i;
}

const NdbError & CTraceNdbConnection::getNdbError(void) const
{
  const NdbError& err = NdbConnection::getNdbError();
  TraceBegin();
  TraceNdbConnection(this);
  TraceMethod("getNdbError");
  TraceReturn();
  TraceNdbError(err);
  TraceEnd();
  return err;
}



// TraceNdb

CTraceNdb::CTraceNdb(const char* aDataBase)
: Ndb(aDataBase) 
{
  TraceBegin();
  TraceNdb(this);
  TraceMethod("Ndb");
  TraceString(aDataBase);
  TraceReturn();
  TraceVoid();
  TraceEnd();
}

CTraceNdbSchemaCon* CTraceNdb::startSchemaTransaction() 
{ 
  NdbSchemaCon* pNdbSchemaCon = Ndb::startSchemaTransaction();
  TraceBegin();
  TraceNdb(this);
  TraceMethod("startSchemaTransaction");
  TraceReturn();
  TraceNdbSchemaCon(pNdbSchemaCon);
  TraceEnd();
  return (CTraceNdbSchemaCon*)pNdbSchemaCon;
}

void CTraceNdb::closeSchemaTransaction(CTraceNdbSchemaCon* aSchemaCon)
{
  Ndb::closeSchemaTransaction(aSchemaCon);
  TraceBegin();
  TraceNdb(this);
  TraceMethod("closeSchemaTransaction");
  TraceReturn();
  TraceVoid();
  TraceEnd();
}

CTraceNdbConnection* CTraceNdb::startTransaction()
{ 
  NdbConnection* pNdbConnection = Ndb::startTransaction();
  TraceBegin();
  TraceNdb(this);
  TraceMethod("startTransaction");
  TraceReturn();
  TraceNdbConnection(pNdbConnection);
  TraceEnd();
  return (CTraceNdbConnection*)pNdbConnection;
}

void CTraceNdb::closeTransaction(CTraceNdbConnection* aConnection)
{
  Ndb::closeTransaction(aConnection);
  TraceBegin();
  TraceNdb(this);
  TraceMethod("closeTransaction");
  TraceNdbConnection(aConnection);
  TraceReturn();
  TraceVoid();
  TraceEnd();
}


