campo-sirio/include/odbc_loc.cpp

#include <wx/wx.h>
#include <wx/db.h>
#include <wx/mstream.h>

#include <codeb.h>

///////////////////////////////////////////////////////////
// TDataBase
///////////////////////////////////////////////////////////

class TDataBase
{
  wxDbConnectInf m_ci;
  wxDb* m_db;

public:
	bool Open(const wxString& dsn, const wxString& user, 
						const wxString& password, const wxString& path);
	bool IsOpen() const;
	void Close();
	wxDb& DataBase() { return *m_db; } 

	TDataBase();
	virtual ~TDataBase();
};

bool TDataBase::Open(const wxString& dsn, const wxString& user, 
										 const wxString& password, const wxString& path)
{
  Close();

  m_ci.SetDsn(dsn);
  m_ci.SetUserID(user);
  m_ci.SetPassword(password);
  m_ci.SetDefaultDir(path);
	
  if (m_ci.AllocHenv())
	{
		m_db = ::wxDbGetConnection(&m_ci, false); // Forward only?
		if (m_db == NULL)
      m_ci.FreeHenv();
	}

	return IsOpen();
}

void TDataBase::Close()
{
  if (m_db)
	{
		m_db->SetSqlLogging(sqlLogOFF);
		::wxDbFreeConnection(m_db);
		m_db = NULL;
		m_ci.FreeHenv();
	}
}

bool TDataBase::IsOpen() const
{
	return m_db != NULL;
}

TDataBase::TDataBase(), m_db(NULL)
{
	m_ci.Henv = 0;
	DeleteContents(true);
}

TDataBase::~TDataBase()
{
	Close();
}

///////////////////////////////////////////////////////////
// TDataBaseList
///////////////////////////////////////////////////////////

class TDataBaseList : public wxHashTable
{
	wxString m_strUser, m_strPassword;

protected:
	wxString& User();
	wxString& Password();

public:
	TDataBase& db(const wxString& path);
  TDataBaseList() : wxHashTable(wxKEY_STRING) { }
};

static DataBaseList theDataBaseList;

wxString& TDataBaseList::User()
{
	if (m_strUser.IsEmpty())
	{
		// TBI Read user and password
	}
	return m_strUser;
}

wxString& TDataBaseList::Password()
{
	if (m_strPassword.Isempty())
		User();  // Initialize both User and Password
	return m_strPassword;
}

wxString& TDataBaseList::Dsn(const wxString& dbpath)
{
	wxString study;
	long firm = -1;
	for (int i = dbpath.GetLength()-1; i >= 0; i--)
		if (dbpath[i] == '\\' || dbpath[i] == '/')
		{
			firm = atol(dbpath.Mid(i+1));
			break;
		}
	for (int j = i-1; j >= 0; j--)
		if (dbpath[j] == '\\' || dbpath[j] == '/')
		{
			study = dbpath.Mid(j+1, i-j);
			break;
		}
	wxString dsn = study;
	if (firm > 0)
		dsn << firm;
	return dsn;
}

TDataBase& TDataBaseList::db(const wxString& dbpath)
{
  wxString dsn = Dsn(dbpath);
	TDataBase* d = (TDataBase*)Get(dsn);
	if (d == NULL)
	{
		d = new TDataBase;
		Put(dsn, d); 
		bool ok = d->Open(dsn, User(), Password(), dbpath);
		if (!ok)
		{
			wxString msg = wxString::Format("L'utente %s non <20> abilitato all'uso del database %s\n"
				                              "corrispondente agli archivi in %s",
				                              User(), dsn, dbpath);
			wxMessageBox(msg, "Errore");
			exit(0);
		}
	}
  return *d;
}

/*--------------------------------------------------------------------------
  inizializzazione di CodeBase e delle variabili necessarie
  questa funzione deve essere chiamata SOLO una volta all'interno
  di ciascun eseguibile
  --------------------------------------------------------------------------*/
void DB_init(void)
{
}

/*--------------------------------------------------------------------------
  reset di CodeBase
  questa funzione dovrebbe essere chiamata prima di uscire da un eseguibile
  per una questione di correttezza formale. Non usandola comunque non acca-
  de niente di drammatico
  --------------------------------------------------------------------------*/
void DB_exit(void)
{
	::wxDbCloseConnections();
}

/*-------------------------------------------------------------------------
  apertura del file 'filename'. Il parametro mode consente se != 0 l'apertura
  esclusiva. Il parametro index consente se == 0 l'apertura senza indici.
	Ritorna l'handle del file aperto oppure -1 in caso di errore
  --------------------------------------------------------------------------*/
int  DB_open(const char *filename,int mode,int index)
{
  return -1;
}


/*-------------------------------------------------------------------------
  chiusura del database inviduato da handle
  torna -1 se il database non puo essere chiuso, 0 altrimenti
  --------------------------------------------------------------------------*/
int  DB_close(int handle)
{
  return 0;
}

/*-------------------------------------------------------------------------
  torna il puntatore al buffer del record del database individuato da
  handle. In caso di errore torna (char *) 0
  --------------------------------------------------------------------------*/
char *DB_getrecord(int handle)
{
  return NULL;
}

/*-------------------------------------------------------------------------
  torna la lunghezza del record
  --------------------------------------------------------------------------*/
int  DB_reclen(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  torna la lunghezza della chiave corrente
  --------------------------------------------------------------------------*/

int DB_keylen(int handle)
{
  return 0;
}

/*-------------------------------------------------------------------------
  torna il numero del record attuale
  --------------------------------------------------------------------------*/
long int DB_recno(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  torna il numero complessivo dei records presenti nell'archivio
  --------------------------------------------------------------------------*/
long int DB_reccount(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  seleziona un indice sul database specificato
  torna -1 se errore, altrimenti 0
  --------------------------------------------------------------------------*/
int  DB_tagselect(int handle,int index_no)
{
  return -1;
}


/*-------------------------------------------------------------------------
  torna il numero dell'indice selezionato
  torna -1 se errore
  --------------------------------------------------------------------------*/
int DB_tagget(int handle)
{
  return -1;
}

/*-------------------------------------------------------------------------
  si posiziona sul primo record
  torna -1 se errore
  --------------------------------------------------------------------------*/
int DB_first(int handle)
{
  return -1;
}


/*-------------------------------------------------------------------------
  si posiziona sull'ultimorecord
  torna -1 se errore
  --------------------------------------------------------------------------*/
int DB_last(int handle)
{
  return -1;
}


/*-------------------------------------------------------------------------
  skip avanti di un record
  --------------------------------------------------------------------------*/
int DB_next(int handle)
{
  return -1;
}

/*-------------------------------------------------------------------------
  skip indietro di un record
  --------------------------------------------------------------------------*/
int DB_prev(int handle)
{
  return -1;
}


/*-------------------------------------------------------------------------
  skip di n records
  --------------------------------------------------------------------------*/
int DB_skip(int handle,long int recno)
{
  return -1;
}

/*-------------------------------------------------------------------------
  locka il record attuale
  --------------------------------------------------------------------------*/
int DB_lock(int handle)
{
  return -1;
}

/*-------------------------------------------------------------------------
  slocka il record attuale
  --------------------------------------------------------------------------*/
int DB_unlock(int handle)
{
  return -1;
}

/*-------------------------------------------------------------------------
  cerca la chiave, torna r4after se not found ma si e' posizionato sul record
  successivo, se torna r4eof e' su eof
  --------------------------------------------------------------------------*/
int DB_seek(int handle,char *key)
{
  return -1;
}

/*-------------------------------------------------------------------------
  torna 1 se eof, 0 altrimenti
  --------------------------------------------------------------------------*/
int DB_eof(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  torna 1 se tof, 0 altrimenti
  --------------------------------------------------------------------------*/
int DB_bof(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  legge un record per numero record
  --------------------------------------------------------------------------*/
int DB_go(int handle,long recno)
{
	return -1;
}

/*-------------------------------------------------------------------------
  cancella il record attuale. Non cancella le chiavi.
  --------------------------------------------------------------------------*/
int DB_delete(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  ripristina il record attuale
  --------------------------------------------------------------------------*/
int DB_recall(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  
  --------------------------------------------------------------------------*/
int DB_flush(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  riscrive il record attuale
  --------------------------------------------------------------------------*/
int DB_rewrite(int handle)
{
	return -1;
}


/*-------------------------------------------------------------------------
  appende il record attuale
  --------------------------------------------------------------------------*/
int DB_add(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  Blocca in modo esclusivo il file dati ed indice
  --------------------------------------------------------------------------*/
int DB_lockfile(int handle)
{
  return -1;
}

/*-------------------------------------------------------------------------
  Compatta il file dati
  --------------------------------------------------------------------------*/
int DB_packfile(short vis, const char * filename, long eod)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Compatta il file memo
  --------------------------------------------------------------------------*/
int DB_packmemo(short vis, const char * filename)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Elimina i record duplicati
  --------------------------------------------------------------------------*/
int DB_clean_file(int handle, char * filename, char * ff, RecDes * r, short vis)
{
  return -1;
}

/*-------------------------------------------------------------------------
  Compatta gli indici
  --------------------------------------------------------------------------*/
int DB_packindex(short vis, const char * filename, RecDes *r, long *peod, bool ask)
{
  return 0;
}


/*-------------------------------------------------------------------------
  costruisce il file filename
  --------------------------------------------------------------------------*/

int DB_build(const char * filename, RecDes *r)
{
  return -1;
}

/*-------------------------------------------------------------------------
  reperisce il tracciato record e la stringa di definizione delle chiavi
  Stringa di definizione chiavi:
  expression1|unique1$expression2|unique2$expression3|unique3
  --------------------------------------------------------------------------*/

int DB_recinfo(const char * filename, FileDes *d, RecDes *r, char* keys) 
{
  return -1;
}

/*-------------------------------------------------------------------------
  ritorna l'ultimo errore
  --------------------------------------------------------------------------*/
int DB_get_error(void)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Azzera la viarabile globale d'errore
  --------------------------------------------------------------------------*/

void DB_zero_error(void)
{
}

/*-------------------------------------------------------------------------
  Si posiziona sull'indice attivo alla chiave indicata, restituisce
  la prima chiave che trova >= a from. (TCursor)
  --------------------------------------------------------------------------*/

int DB_index_seek(int handle, char* from)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Ritorna il numero di record corrispondente alla chiave corrente
  --------------------------------------------------------------------------*/

long DB_index_recno(int handle)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Si posiziona sulla chiave successiva dell'indice corrente
  --------------------------------------------------------------------------*/
long DB_index_next(int handle)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Restituisce la chiave corrente
  --------------------------------------------------------------------------*/

char* DB_index_getkey(int handle)
{
  return NULL;
}

/*-------------------------------------------------------------------------
  Restituisce vero se l'indice e' alla fine
  --------------------------------------------------------------------------*/

int DB_index_eof(int handle)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Blocca il record indicato
  --------------------------------------------------------------------------*/

int DB_lock_rec(int handle,long nrec)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Ritorna vero(non zero) se il file dati od indice sono stati bloccati
  in modo esclusivo dalla presente applicazione, non da altri programmi!!!
  --------------------------------------------------------------------------*/

int DB_file_locked(int handle)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Ritorna vero se il record nrec e' bloccato dalla presente applicazione,
  non da altri programmi!!!
  --------------------------------------------------------------------------*/

int DB_rec_locked(int handle,long nrec)
{
  return 0;
}

/*-------------------------------------------------------------------------
  restituisce la configurazione della libreria
  --------------------------------------------------------------------------*/

long DB_getconf()
{
  return 0;
}

/*-------------------------------------------------------------------------
  Restituisce il numero di versione scritto sull'header dell'indice
  --------------------------------------------------------------------------*/

long DB_changed(int handle)
{
  return 0;
}

char* DB_memoptr( const int handle, const char * fieldname )
{
  return NULL;
}

int DB_memowrite( const int handle, const char * fieldname, const char * data )
{
  return NULL;
}