/*
----
This file is part of SECONDO.

Copyright (C) 2004, University in Hagen, Department of Computer Science,
Database Systems for New Applications.

SECONDO 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; either version 2 of the License, or
(at your option) any later version.

SECONDO 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 SECONDO; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
----



September 2006, M. Spiekermann. Class implementations moved from 
"SecondoInterface.cpp"
into this file.


An overview about System tables is given in the file "SystemInfoRel.cpp".

*/

#ifndef SECONDO_SYSTABLES_H
#define SECONDO_SYSTABLES_H

#include "NList.h"
#include "SystemInfoRel.h"

class CmdTimes : public InfoTuple
{
   int nr;
   std::string cmdStr;
   double elapsedTime;
   double cpuTime;
   double commitTime;
   double queryReal;
   double queryCPU;
   double outObjReal;
   double copyReal;

   public:
   CmdTimes( int num,
             const std::string& cmd,
             double realT,
             double cpuT,
             double commitT,
             double qRT,
             double qCT,
             double outRT,
             double cpRT ) :
     nr(num),
     cmdStr(cmd),
     elapsedTime(realT),
     cpuTime(cpuT),
     commitTime(commitT),
     queryReal(qRT),
     queryCPU(qCT),
     outObjReal(outRT),
     copyReal(cpRT)
   {
   }
   virtual ~CmdTimes() {}

   virtual NList valueList() const
   {
     NList value;
     value.makeHead( NList(nr) );
     value.append( NList().textAtom(cmdStr) );
     value.append( NList(elapsedTime) );
     value.append( NList(cpuTime) );
     value.append( NList(commitTime) );
     value.append( NList(queryReal) );
     value.append( NList(queryCPU) );
     value.append( NList(outObjReal) );
     value.append( NList(copyReal) );
     return value;
   }

   virtual std::ostream& print(std::ostream& os) const
   {
      os << nr << sep << cmdStr << sep << elapsedTime << sep << cpuTime;
      return os;
   }

};


class CmdTimesRel : public SystemInfoRel
{
   public:
   CmdTimesRel(const std::string& name) : SystemInfoRel(name)
   {}

   virtual ~CmdTimesRel() {}

   virtual void initSchema()
   {
     addAttribute("CmdNr",       sym.INT()  );
     addAttribute("CmdStr",      sym.TEXT() );
     addAttribute("ElapsedTime", sym.REAL() );
     addAttribute("CpuTime",     sym.REAL() );
     addAttribute("CommitTime",  sym.REAL() );
     addAttribute("QueryReal",   sym.REAL() );
     addAttribute("QueryCPU",    sym.REAL() );
     addAttribute("OutObjReal",  sym.REAL() );
     addAttribute("CopyReal",    sym.REAL() );
   }

};

class CmdCtr : public InfoTuple
{
   int nr;
   std::string ctrStr;
   long value;

   public:
   CmdCtr(int num, const std::string& cmd, long ctrVal) :
     nr(num),
     ctrStr(cmd),
     value(ctrVal)
   {}
   virtual ~CmdCtr() {}

   virtual NList valueList() const
   {
     NList list;
     list.makeHead( NList(nr) );
     list.append( NList().stringAtom(ctrStr) );
     list.append( NList().intAtom(value) );
     return list;
   }


   virtual std::ostream& print(std::ostream& os) const
   {
      os << nr << sep << ctrStr << sep << value;
      return os;
   }
};


class CmdCtrRel : public SystemInfoRel
{
   public:
   CmdCtrRel(const std::string& name) : SystemInfoRel(name)
   {}
   virtual ~CmdCtrRel() {}

   virtual void initSchema()
   {
     addAttribute("CtrNr",  sym.INT()    );
     addAttribute("CtrStr", sym.STRING() );
     addAttribute("Value",  sym.INT()    );
   }
};

class DerivedObjInfo : public InfoTuple
{
   std::string name;
   std::string value;
   std::string usedObjs;

   public:
   DerivedObjInfo(const std::string& n, const std::string& v,
                  const std::string&u) :
     name(n),
     value(v),
     usedObjs(u)
   {}
   virtual ~DerivedObjInfo() {}

   virtual NList valueList() const
   {
     NList list;
     list.makeHead( NList().stringAtom(name) );
     list.append( NList().textAtom(value) );
     list.append( NList().textAtom(usedObjs) );
     return list;
   }


   virtual std::ostream& print(std::ostream& os) const
   {
      os << name << sep << value << sep << usedObjs;
      return os;
   }
};



class DerivedObjRel : public SystemInfoRel
{
   public:
   DerivedObjRel(const std::string& name) : SystemInfoRel(name, true)
   {}
   virtual ~DerivedObjRel() {}

   virtual void initSchema()
   {
     addAttribute("Name",     sym.STRING() );
     addAttribute("Value",    sym.TEXT()   );
     addAttribute("UsedObjs", sym.TEXT()   );
   }
};


class CacheInfoTuple : public InfoTuple, public CacheInfo
{
   public:
   CacheInfoTuple() {}
   virtual ~CacheInfoTuple() {}

   virtual NList valueList() const
   {
     NList value;
     value.makeHead( NList(cstatNr) );
     value.append( NList().intAtom(bytes) );
     value.append( NList().intAtom(regsize) );
     value.append( NList().intAtom(cache_hit) );
     value.append( NList().intAtom(cache_miss) );
     value.append( NList().intAtom(page_create) );
     value.append( NList().intAtom(page_in) );
     value.append( NList().intAtom(page_out) );
     value.append( NList().intAtom(pages) );
     return value;
   }

   virtual std::ostream& print(std::ostream& os) const
   {
      os << cstatNr << sep
         << bytes << sep
         << regsize << sep
         << cache_hit << sep
         << cache_miss << sep
         << page_create << sep
         << page_in << sep
         << page_out << sep
         << pages << endl;
      return os;
   }
};

class CacheInfoRel : public SystemInfoRel
{
   public:
   CacheInfoRel(const std::string& name) : SystemInfoRel(name)
   {}
   virtual ~CacheInfoRel() {}

   virtual void initSchema()
   {
     addAttribute("CStatNr",   sym.INT() );
     addAttribute("Bytes",     sym.INT() );
     addAttribute("RegSize",   sym.INT() );
     addAttribute("Hits",      sym.INT() );
     addAttribute("Misses",    sym.INT() );
     addAttribute("Pages_New", sym.INT() );
     addAttribute("Pages_In",  sym.INT() );
     addAttribute("Pages_Out", sym.INT() );
     addAttribute("Pages_All", sym.INT() );
   }
};

class FileInfoTuple : public InfoTuple, public FileInfo
{
   public:
   FileInfoTuple(FileInfo* fstat)
   {
     fstatNr = fstat->fstatNr;
     file_name = fstat->file_name;
     pagesize = fstat->pagesize;
     cache_hit = fstat->cache_hit;
     cache_miss = fstat->cache_miss;
     page_create = fstat->page_create;
     page_in = fstat->page_in;
     page_out = fstat->page_out;
   }
   virtual ~FileInfoTuple() {}

   virtual NList valueList() const
   {
     NList value;
     value.makeHead( NList(fstatNr) );
     value.append( NList().textAtom(file_name) );
     value.append( NList().intAtom(pagesize) );
     value.append( NList().intAtom(cache_hit) );
     value.append( NList().intAtom(cache_miss) );
     value.append( NList().intAtom(page_create) );
     value.append( NList().intAtom(page_in) );
     value.append( NList().intAtom(page_out) );
     return value;
   }

   virtual std::ostream& print(std::ostream& os) const
   {
      os << fstatNr << sep
         << file_name << sep
         << pagesize << sep
         << cache_hit << sep
         << cache_miss << sep
         << page_create << sep
         << page_in << sep
         << page_out << endl;
      return os;
   }
};


class FileInfoRel : public SystemInfoRel
{
   public:
   FileInfoRel(const std::string& name) : SystemInfoRel(name)
   {}
   virtual ~FileInfoRel() {}

   virtual void initSchema()
   {
     addAttribute("FStatNr",   sym.INT()  );
     addAttribute("File",      sym.TEXT() );
     addAttribute("PageSize",  sym.INT()  );
     addAttribute("Hits",      sym.INT()  );
     addAttribute("Misses",    sym.INT()  );
     addAttribute("Pages_New", sym.INT()  );
     addAttribute("Pages_In",  sym.INT()  );
     addAttribute("Pages_Out", sym.INT()  );
   }
};

class TypeInfoTuple : public InfoTuple
{
   public:
   std::string type;
   int cppClassSize;
   int numOfFlobs;
   std::string algebra;
   std::string signature;
   std::string typeListExample;
   std::string listRep;
   std::string valueListExample;
   std::string persistencyMode;
   std::string remark;

   TypeInfoTuple() {

     type = "";
     cppClassSize = 0;
     numOfFlobs = 0;
     signature = "";
     algebra = "";
     typeListExample = "";
     listRep = "";
     valueListExample = "";
     persistencyMode = "";
     remark = "";
   }
   virtual ~TypeInfoTuple() {}

   virtual NList valueList() const
   {
     NList list;
     list.makeHead( NList().stringAtom(type) );
     list.append( NList().stringAtom(algebra) );
     list.append( NList().textAtom(signature) );
     list.append( NList().textAtom(typeListExample) );
     list.append( NList().textAtom(listRep) );
     list.append( NList().textAtom(valueListExample) );
     list.append( NList().intAtom(cppClassSize) );
     list.append( NList().intAtom(numOfFlobs) );
     list.append( NList().stringAtom(persistencyMode) );
     list.append( NList().textAtom(remark) );
     return list;
   }

   virtual std::ostream& print(std::ostream& os) const
   {
      os << type << sep
         << cppClassSize << endl;
      return os;
   }
};


class TypeInfoRel : public SystemInfoRel
{
   public:
   TypeInfoRel(const std::string& name) : SystemInfoRel(name)
   {}
   virtual ~TypeInfoRel() {}

   virtual void initSchema()
   {
     addAttribute("Type",             sym.STRING() );
     addAttribute("Algebra",          sym.STRING() );
     addAttribute("Signature",        sym.TEXT()   );
     addAttribute("TypeListExample",  sym.TEXT()   );
     addAttribute("ListRep",          sym.TEXT()   );
     addAttribute("ValueListExample", sym.TEXT()   );
     addAttribute("CppClassSize",     sym.INT()    );
     addAttribute("NumOfFlobs",       sym.INT()    );
     addAttribute("PersistencyMode",  sym.STRING() );
     addAttribute("Remark",           sym.TEXT()   );
   }
};

class OperatorInfoTuple : public InfoTuple
{
   public:
   std::string name;
   std::string algebra;
   std::string signature;
   std::string syntax;
   std::string meaning;
   std::string example;
   std::string remark;
   std::string result;
   bool supportsProgress;

   OperatorInfoTuple() {

     name = "";
     algebra = "";
     signature = "";
     syntax = "";
     meaning = "";
     example = "";
     result = "";
     remark = "";
     supportsProgress = false;
   }
   virtual ~OperatorInfoTuple() {}

   virtual NList valueList() const
   {
     NList list;
     list.makeHead( NList().stringAtom(name) );
     list.append( NList().stringAtom(algebra) );
     list.append( NList().textAtom(signature) );
     list.append( NList().textAtom(syntax) );
     list.append( NList().textAtom(meaning) );
     list.append( NList().textAtom(example) );
     list.append( NList().textAtom(result) );
     list.append( NList().textAtom(remark) );
     list.append( NList().boolAtom(supportsProgress));
     return list;
   }

   virtual std::ostream& print(std::ostream& os) const
   {
      os << name << sep
         << algebra << endl;
      return os;
   }
};


class OperatorInfoRel : public SystemInfoRel
{
   public:
   OperatorInfoRel(const std::string& name) : SystemInfoRel(name)
   {}
   virtual ~OperatorInfoRel() {}

   virtual void initSchema()
   {
     addAttribute("Name",      sym.STRING() );
     addAttribute("Algebra",   sym.STRING() );
     addAttribute("Signature", sym.TEXT()   );
     addAttribute("Syntax",    sym.TEXT()   );
     addAttribute("Meaning",   sym.TEXT()   );
     addAttribute("Example",   sym.TEXT()   );
     addAttribute("Result",    sym.TEXT()   );
     addAttribute("Remark",    sym.TEXT()   );
     addAttribute("SupportsProgress",    sym.BOOL()   );
   }
};


class OperatorUsageTuple : public InfoTuple
{
   public:
   std::string name;
   std::string algebra;
   int    vmid;
   int    calls;

   OperatorUsageTuple():InfoTuple(),name(""),algebra(""),vmid(0),calls(0) { }
   virtual ~OperatorUsageTuple() {}

   virtual NList valueList() const
   {
     NList list;
     list.makeHead( NList().stringAtom(name) );
     list.append( NList().stringAtom(algebra) );
     list.append( NList().intAtom(vmid));
     list.append( NList().intAtom(calls) );
     return list;
   }

   virtual std::ostream& print(std::ostream& os) const
   {
      os << name << sep
         << algebra << sep
         << calls << endl;
      return os;
   }
};


class OperatorUsageRel : public SystemInfoRel
{
   public:
   OperatorUsageRel(const std::string& name) : SystemInfoRel(name)
   {}
   virtual ~OperatorUsageRel() {}

   virtual void initSchema()
   {
     addAttribute("Algebra",  sym.STRING() );
     addAttribute("Operator", sym.STRING() );
     addAttribute("ValueMap", sym.INT());
     addAttribute("Calls",    sym.INT()    );
   }
};



#endif