dbtc.h

/* dbtc.h */
/* $Id: dbtc.h,v 1.41 2009/03/27 09:37:00 vlad Exp $ */

/* Encoding: ISO-8859-5 (GOST) */

#ifndef __dbtc_h

#define __dbtc_h

#include <mix/General.h>
#include <mix/Exceptions.h>
#include <mix/Types.h>
#include <mix/units.h>
#include <mix/mutex.h>
#include <ldb/dbdefs.h>
#include <ldb/dbnamedefs.h>

#ifdef __cplusplus
extern "C" {
#endif  /* __cplusplus */

typedef void*   dbHandle;

#define DB_PRECISION    (0.00001)

/* Order flags
 * ASC -- ascent:  a(i) <= a(i+1)
 * DSC -- descent: a(i) >= a(i+1)
 */
#define DB_ASC1     0
#define DB_DSC1     (1<<0)
#define DB_ASC2     0
#define DB_DSC2     (1<<1)
#define DB_ASC3     0
#define DB_DSC3     (1<<2)
#define DB_ASC      (DB_ASC1|DB_ASC2|DB_ASC3)
#define DB_DSC      (DB_DSC1|DB_DSC2|DB_DSC3)

/* Mode of data base open */
#define DB_CREATE   DbCreateFile    
#define DB_WRITE    DbReadWriteFile 
#define DB_READ     DbReadOnlyFile  
#define DB_MEMORY   DbMemory    
/*************************************************************
 * Open-close/create-delete operations
 *************************************************************/

dbHandle    dbOpen (const char* szProject,
            dbNameStruct* pName,
            DbAccess mode);

dbHandle    dbOpenName (const char* szProject,
                char* szDbFileName,
                DbAccess mode);

dbHandle    dbOpenItem (const char* szProject,
                dbItem* item,
                DbAccess mode);

dbHandle    dbOpenItemEx (const char* szProject,
                  dbItem* item,
                  DbAccess mode,
                  dbNameStruct* dbmask);

dbHandle    dbOpenList (const char* szProject,
                const char* szTableType,
                DbAccess mode);

dbHandle    dbOpenIndex (const char* szProject,
                 const char* szTableType,
                 DbIndex lineIndex,
                 DbAccess mode);

dbHandle    dbOpenPointer (dbPointer* pdb,
                   DbAccess mode);

void        dbReopen (dbHandle dbh,
              DbAccess mode);

void        dbClose (dbHandle dbh);

void        dbRemove (const char* szProject,
              const dbNameStruct* pName);

void        dbRename (const char* szProject,
              const dbNameStruct* pOldName,
              const dbNameStruct* pNewName);

void        dbRestoreLock (dbHandle dbh);

MutexId*    dbMutex (dbHandle dbh);


/*************************************************************
 * Operations for descriptor base
 *************************************************************/

char**      dbTableTypeList (int* pNumber);

Logic       dbCheckTable (const char* szTableName);

ErrCode     dbRegisterTableType (const char* ttname,
                     unsigned dmns_n,
                     const DbDomainDesc* dmns);

ErrCode     dbFetchTableType (const char* ttname,
                  unsigned* dmns_n,
                  DbDomainDesc** dmns);

/*************************************************************
 * Infomation and protection around modification.
 *************************************************************/

Logic       dbIsModified (dbHandle dbh);

Logic       dbIsModifiable (dbHandle dbh);

void        dbSetModified (dbHandle dbh, Logic bFlag);

void        dbSetModifiable (dbHandle dbh, Logic bFlag);

/*************************************************************
 * Table information operations
 *************************************************************/

const char* dbTableType (dbHandle dbh);

const char* dbFileName (dbHandle dbh);

const dbNameStruct* dbStructuredName (dbHandle dbh);

const char* dbProject (dbHandle dbh);

DbIndex     dbLinesCount (dbHandle dbh);

int     dbColumnsCount (dbHandle dbh);

dbNameStruct*   dbNameByItem (const char* szProject,
                  dbItem* dbi, dbNameStruct* dbns);

ErrCode     dbThisTableType (dbHandle dbh,
                 unsigned* dmns_n,
                 DbDomainDesc** dmns);

/*************************************************************
 * Physical units support
 *************************************************************/

void        dbSetUnit (dbHandle dbh,
               const char* szColumnName,
               UnitId eUnit);

UnitId      dbGetUnit (dbHandle dbh,
               const char* szColumnName);

CategoryId  dbColumnUnitCateg (dbHandle dbh,
                   const char* szColumnName);

/*************************************************************
 * The whole table operations
 *************************************************************/

void        dbCleanTable (dbHandle dbh);

void        dbFlush (dbHandle dbh);

void        dbSort1 (dbHandle dbh,
             const char* szColumnName1,
             int orderFlags);

void        dbSort2 (dbHandle dbh,
             const char* szColumnName1,
             const char* szColumnName2,
             int orderFlags);

void        dbSort3 (dbHandle dbh,
             const char* szColumnName1,
             const char* szColumnName2,
             const char* szColumnName3,
             int orderFlags);

/*************************************************************
 * Per column operations
 *************************************************************/

void        dbColumnName (dbHandle dbh,
                  int columnIndex,
                  char* szColumnName);

AtomType    dbColumnType (dbHandle dbh,
                  const char* szColumnName);

int     dbColumnDim (dbHandle dbh,
                 const char* szColumnName);

Logic       dbCheckColumn (dbHandle dbh,
                   const char* szColumnName);

int     dbColumnDefaultInt (dbHandle dbh,
                    const char* szColumnName);

float       dbColumnDefaultFloat (dbHandle dbh,
                      const char* szColumnName);

Logic       dbCheckNumericColumn (dbHandle dbh,
                      const char* szColumnName);

/*************************************************************
 * Per line operations
 *************************************************************/

void        dbAddLine (dbHandle dbh);

void        dbAddLines (dbHandle dbh, DbIndex lines);

void        dbInsertLine (dbHandle dbh, DbIndex index);

void        dbInsertLines (dbHandle dbh, DbIndex index, DbIndex lines);

void        dbRemoveLine (dbHandle dbh, DbIndex index);

void        dbRemoveLines (dbHandle dbh, DbIndex startIndex,
                   DbIndex endIndex);

void        dbMergeTables (dbHandle dbhDst, dbHandle dbhSrc);

void        dbCopyTables (dbHandle dbhDst, DbIndex iWhere,
                  dbHandle dbhSrc, DbIndex iFrom, DbIndex nLines);

/*************************************************************
 * Get scalar per cell operations
 *************************************************************/

double      dbGetFloat (dbHandle dbh, DbIndex lineIndex,
                const char* szColumnName);

int     dbGetInt (dbHandle dbh, DbIndex lineIndex,
              const char* szColumnName);

long long   dbGetInt8 (dbHandle dbh, DbIndex lineIndex,
               const char* szColumnName);

char        dbGetChar (dbHandle dbh, DbIndex lineIndex,
               const char* szColumnName);

void        dbGetPtr (dbHandle dbh, DbIndex lineIndex,
              const char* szColumnName,
              dbPointer* pPtr);

void        dbGetPointer (dbHandle dbh, DbIndex lineIndex,
                  dbPointer* pPtr);

/*************************************************************
 * Get vector per cell operations
 *************************************************************/

char*       dbGetString (dbHandle dbh, DbIndex lineIndex,
                 const char* szColumnName,
                 char* sValue);

void        dbGetFloatAr (dbHandle dbh, DbIndex lineIndex,
                  const char* szColumnName,
                  float* ar);

void        dbGetDoubleAr (dbHandle dbh, DbIndex lineIndex,
                const char* szColumnName,
                double* ar);

void        dbGetIntAr (dbHandle dbh, DbIndex lineIndex,
                const char* szColumnName,
                int* ar);

void        dbGetInt8Ar (dbHandle dbh, DbIndex lineIndex,
                 const char* szColumnName,
                 long long* ar);

/*************************************************************
 * Read the whole column of cells
 *************************************************************/

void        dbGetIntColumn (dbHandle dbh,
                DbIndex lineStart,
                DbIndex linesCnt,
                const char* szColumnName,
                int* ar);

void            dbGetIntArColumn (dbHandle dbh,
                  DbIndex lineStart,
                  DbIndex linesCnt,
                  const char* szColumnName,
                  int** arOfAr);

void        dbGetInt8Column (dbHandle dbh,
                 DbIndex lineStart,
                 DbIndex linesCnt,
                 const char* szColumnName,
                 long long* ar);

void            dbGetInt8ArColumn (dbHandle dbh,
                   DbIndex lineStart,
                   DbIndex linesCnt,
                   const char* szColumnName,
                   long long** arOfAr);

void        dbGetFloatColumn (dbHandle dbh,
                  DbIndex lineStart,
                  DbIndex linesCnt,
                  const char* szColumnName,
                  float* ar);

void        dbGetFloatArColumn (dbHandle dbh,
                    DbIndex lineStart,
                    DbIndex linesCnt,
                    const char* szColumnName,
                    float** arOfAr);

void        dbGetDoubleColumn (dbHandle dbh,
                   DbIndex lineStart,
                   DbIndex linesCnt,
                   const char* szColumnName,
                   double* ar);

void        dbGetDoubleArColumn (dbHandle dbh,
                     DbIndex lineStart,
                     DbIndex linesCnt,
                     const char* szColumnName,
                     double** arOfAr);

Logic       dbCheckEmptyValue (dbHandle dbh, DbIndex lineIndex,
                   const char* szColumnName);

/*************************************************************
 * Set scalar per cell operations
 *************************************************************/

void        dbSetFloat (dbHandle dbh, DbIndex lineIndex,
                const char* szColumnName, double value);

void        dbSetInt (dbHandle dbh, DbIndex lineIndex,
              const char* szColumnName, int value);

void        dbSetInt8 (dbHandle dbh, DbIndex lineIndex,
               const char* szColumnName, long long value);

void        dbSetChar (dbHandle dbh, DbIndex lineIndex,
               const char* szColumnName, char value);

void        dbSetPtr (dbHandle dbh, DbIndex lineIndex,
              const char* szColumnName,
              const dbPointer* pPtr);

void        dbSetPointer (dbHandle dbh, DbIndex lineIndex,
                  const dbPointer* pPtr);

/*************************************************************
 * Set vector per cell operations
 *************************************************************/

void        dbSetString (dbHandle dbh, DbIndex lineIndex,
                 const char* szColumnName,
                 const char* sValue);

void        dbSetFloatAr (dbHandle dbh, DbIndex lineIndex,
                  const char* szColumnName,
                  const float* ar);

void        dbSetDoubleAr (dbHandle dbh, DbIndex lineIndex,
                  const char* szColumnName,
                  const double* ar);

void        dbSetIntAr (dbHandle dbh, DbIndex lineIndex,
                const char* szColumnName,
                const int* ar);

void        dbSetInt8Ar (dbHandle dbh, DbIndex lineIndex,
                 const char* szColumnName,
                 const long long* ar);

/*************************************************************
 * Write the whole column of cells
 *************************************************************/

void        dbSetIntColumn (dbHandle dbh,
                DbIndex lineStart,
                DbIndex linesCnt,
                const char* szColumnName,
                const int* ar);

void        dbSetIntArColumn (dbHandle dbh,
                  DbIndex lineStart,
                  DbIndex linesCnt,
                  const char* szColumnName,
                  const int** arOfAr);

void        dbSetInt8Column (dbHandle dbh,
                 DbIndex lineStart,
                 DbIndex linesCnt,
                 const char* szColumnName,
                 const long long* ar);

void        dbSetInt8ArColumn (dbHandle dbh,
                   DbIndex lineStart,
                   DbIndex linesCnt,
                   const char* szColumnName,
                   const long long** arOfAr);

void        dbSetFloatColumn (dbHandle dbh,
                  DbIndex lineStart,
                  DbIndex linesCnt,
                  const char* szColumnName,
                  const float* ar);

void        dbSetFloatArColumn (dbHandle dbh,
                    DbIndex lineStart,
                    DbIndex linesCnt,
                    const char* szColumnName,
                    const float** arOfAr);

void        dbSetDoubleColumn (dbHandle dbh,
                   DbIndex lineStart,
                   DbIndex linesCnt,
                   const char* szColumnName,
                   const double* ar);

void        dbSetDoubleArColumn (dbHandle dbh,
                     DbIndex lineStart,
                     DbIndex linesCnt,
                     const char* szColumnName,
                     const double** arOfAr);

void        dbSetEmptyValue (dbHandle dbh, DbIndex lineIndex,
                 const char* szColumnName);


#ifndef __dbtc_vars


extern TLStorage int        dbStatus;

extern volatile double      dbEpsilon;

#endif /* __dbtc_vars */

#ifdef __cplusplus
};
#endif /* __cplusplus */

#endif  /* dbtc.h */