database.h

Go to the documentation of this file.

/***************************************************************************
 database.h
 Basic function for connecting a MySQL embedded database
 -------------------
 copyright            : (C) 2007 CREALP Lucien Schreiber
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef __database_H__
#define __database_H__
 
#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma interface "database.cpp"
#endif
 
#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif
 
#include "mysql.h"
// #include <wx/arrstr.h> // array string
// #include <wx/strconv.h> // unicode conversion
 
// #include <wx/filename.h>
 
#include <wx/buffer.h>
#include <wx/tokenzr.h>  // tokenizer of string
#include <wx/dir.h>  // directory operation (size)
#include <wx/config.h>
#include <wx/fileconf.h>
 
WX_DEFINE_ARRAY_LONG(unsigned long, tmArrayULong);
 
class DataBaseResult;
 
// WX_DEFINE_ARRAY_(int, ArrayOfInts);
 
class DataBase {
  private:
    // member
    bool m_IsLibraryStarted;
    bool m_IsDatabaseOpened;
    bool m_IsDatabaseConnected;
    MYSQL* m_MySQL;
    MYSQL_RES* m_MySQLRes;
    wxString m_DBName;
    wxString m_DBPath;
    wxString m_ErrMsgPath;
 
    // functions
    bool DBLibraryInit(const wxString& datadir);
 
    void DBLibraryEnd();
 
    bool DBUseDataBase(const wxString& dbname);
 
    bool DBIsDataBaseReady();
 
    bool DBGetNextRecord(MYSQL_ROW& record);
 
    bool DBResultsNotNull();
 
  protected:
  public:
    DataBase(const wxString& errmsgpath = wxEmptyString);
 
    virtual ~DataBase();
 
    // database operations
    bool DataBaseCreateNew(const wxString& datadir, const wxString& name);
 
    bool DataBaseOpen(const wxString& datadir, const wxString& name);
 
    bool DataBaseDelete();
 
    wxString DataBaseGetName();
 
    wxString DataBaseGetPath();
 
    wxString DataBaseGetSize(int precision = 2, const wxString& failmsg = _("Not available"));
 
    static wxString DataBaseGetVersion();
 
    wxString DataBaseGetLastError();
 
    // thread operations
    bool DataBaseThreadInit();
 
    void DataBaseThreadEnd();
 
    // query operations
    bool DataBaseQueryNoResults(const wxString& query, bool logerror = true);
 
    bool DataBaseQuery(const wxString& query, bool logerror = true);
 
    int DataBaseQueriesNumber(const wxString& query);
 
    long DataBaseGetLastInsertedID();
 
    long DataBaseGetAffectedRows();
 
    // query transformations
    static bool DataBaseStringEscapeQuery(const wxString& query, wxString& results);
 
    // results operations
    bool DataBaseHasResults();
 
    void DataBaseClearResults();
 
    // results by rows (clear after use)
    bool DataBaseGetResultSize(unsigned int* pcols, long* prows);
 
    bool DataBaseGetNextResult(wxString& result);
 
    bool DataBaseGetNextResult(wxArrayString& results);
 
    bool DataBaseGetNextResult(long& result);
 
    bool DataBaseGetNextResult(wxArrayLong& results);
 
    bool DataBaseGetNextResult(wxDouble& result);
 
    bool DataBaseGetNextResult(wxArrayDouble& results);
 
    bool DataBaseGetNextRowResult(MYSQL_ROW& row, tmArrayULong& lengths);
 
    // results set (auto cleared after use)
    bool DataBaseGetResults(wxArrayString& results);
 
    bool DataBaseGetResults(wxArrayLong& results);
 
    bool DataBaseGetResults(wxArrayDouble& results);
 
    bool DataBaseGetResults(DataBaseResult* results);
};
 
#if (0)
const wxString DATABASE_TYPE_STRING = _T("MYSQL");
 
enum Lang_Flag {
    LANG_UTF8,
    LANG_LATIN1
};
 
//----------------------------------------------------------------------------
// DataBase
//----------------------------------------------------------------------------
class DataBase {
  public:
    // constructors and destructors
    // DataBase();
    //~DataBase();
    //   bool DataBaseOpen(wxString path,enum Lang_Flag flag);
 
    // int DataBaseInitLibrary (const wxString & path);
 
    // bool DataBaseClose ();
 
    // bool DataBaseIsOpen();
 
    // wxString DataBaseGetLastError();
 
    wxArrayString DataBaseListTables();
 
    // static wxString DatabaseGetVersion();
 
    // long DatabaseGetCountResults();
 
    // int DatabaseGetCountCols();
 
    wxArrayString DatabaseListFields(wxString sTable);
 
    bool DataBaseGetAllTableContent(wxString sTable);
 
    // wxArrayString DataBaseGetNextResult();
 
    long DataBaseGetLastInsertID();
 
    // bool DataBaseGetNextResult(wxString & result);
 
    unsigned long* DataBaseGetNextRowResult(MYSQL_ROW& row);
 
    bool DataBaseTableExist(const wxString& tableName);
 
    // int DataBaseGetResultAsInt(bool ClearResultDirect = TRUE);
 
    // long DataBaseGetNextResultAsLong();
 
    // void DataBaseGetNextResultAsLong(wxArrayLong & resultArray);
 
    // double DataBaseGetResultAsDouble();
 
    bool DataBaseIsTableEmpty(const wxString& tableName);
 
    // bool DataBaseQueryNoResult(wxString myQuery, bool logerror = false);
    // bool DataBaseQuery(const wxString & myQuery, bool logerror = false);
 
    // wxArrayLong * DataBaseQuerySafe (const wxString & myQuery);
 
    // bool DataBaseHasResult ();
 
    // bool DataBaseResultExists();
 
    // void DataBaseDestroyResults ();
 
    // int DataBaseQueryMultiple (const wxString & myQuery);
 
    // int DataBaseQueryReal (wxString myQuery);
 
    // wxString DataBaseGetPath();
 
    // wxString DataBaseGetName();
 
    // wxString DatabaseGetCharacterSet();
 
    // bool DataBaseCreateNew(wxString DataBasePath, wxString DataBaseName,enum Lang_Flag Flag=LANG_UTF8);
 
    // wxArrayString DataBaseCutRequest (wxString theRequest);
 
    // wxString DataBaseGetSize (int iPrecision=2);
 
    // static void DataBaseCloseLibrary();
 
    //   static void DataBaseConvertWindowsPath (wxString & spath);
 
    bool DataBaseNewThreadInit();
 
    void DataBaseNewThreadUnInit();
 
    // bool DataBaseQueryBinary(const char * query, bool DestroyResult = FALSE);
 
  protected:
    // MYSQL * pMySQL;
 
    // for storing restults
    // MYSQL_RES * pResults;
    // int m_resultNumber;
    // long m_resultCount;
 
    // storing database path and name.
    // wxString m_DBPath;
    // wxString m_DBName;
 
    // bool IsDatabaseOpen;
 
    // static bool bIsLibInit;
 
    // bool DataBaseConvertFullPath(wxString fullpath);
 
    // wxString DataBaseConvertMYSQLPath(wxString originalPath);
 
    // bool DataBaseSetCharacterSet (enum Lang_Flag myFlag);
};
#endif
 
#endif