hk_database.h

// ****************************************************************************
// copyright (c) 2000-2005 Horst Knorr <hk_classes@knoda.org>
// This file is part of the hk_classes library.
// This file may be distributed and/or modified under the terms of the
// GNU Library Public License version 2 as published by the Free Software
// Foundation and appearing in the file COPYING included in the
// packaging of this file.
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
// ****************************************************************************
#ifndef HK_DATABASE
#define HK_DATABASE
#include <hk_class.h>
#include <list>
#include <vector>
#include <algorithm>
#include "hk_presentation.h"
#include "hk_url.h"
using namespace std;

class hk_connection;
class hk_datasource;
class hk_data;
class hk_dbvisible;
class hk_actionquery;
class hk_form;
class hk_report;
class hk_dsmodevisible;
class hk_databaseprivate;
class hk_dsquery;
class hk_dstable;

typedef hk_form* newform_type(hk_database*,hk_class*);
typedef hk_report* newreport_type(hk_database*,hk_class*);
typedef hk_dstable* newtable_type(hk_class*);
typedef hk_dsquery* newquery_type(hk_class*);

class hk_database:public hk_class
{
    friend class hk_datasource;
    friend class hk_actionquery;
    friend class hk_connection;
    friend class hk_dbvisible;
    friend class hk_presentation;
    public:
        virtual     ~hk_database();

virtual bool    set_name(const hk_string& n);
        hk_string   name(void);

        vector<hk_string>* tablelist(bool with_systemtable=false);

        vector<hk_string>* viewlist();
        vector<hk_string>* tableviewlist(bool with_systemtable=false);


        vector<hk_string>* querylist(void);
        vector<hk_string>* formlist(void);
        vector<hk_string>* reportlist(void);
        hk_datasource* new_table(const hk_string& name="",hk_presentation* p=NULL);
        hk_datasource* new_resultquery(hk_presentation* p=NULL);
        hk_actionquery*   new_actionquery(void);


        hk_datasource* new_view(const hk_string& name="",hk_presentation* p=NULL);

        hk_datasource*  load_datasource(const hk_string& name,datasourcetype dt=dt_table,hk_presentation* p=NULL);

        bool    delete_table(const hk_string& table,enum_interaction x=interactive);
        bool    delete_view(const hk_string& view, enum_interaction x=interactive);
        bool    table_exists(const hk_string& tablename);
        bool    view_exists(const hk_string& viewname);
        bool    query_exists(const hk_string& queryname);
        bool    form_exists(const hk_string& formname);
        bool    report_exists(const hk_string& reportname);

        hk_connection*  connection(void)const{return p_connection;}
        ofstream* savestream(const hk_string&name,filetype type,bool ask_before_overwrite=true );
        ofstream* savestream(const hk_string&name,filetype type,bool ask_before_overwrite,bool with_header,bool ask_for_new_name=false );
    STRINGSTREAM* savestringstream(filetype type);

    STRINGSTREAM* savestringstream(filetype type,bool with_header);



        bool  delete_file(const hk_string& name,filetype type,enum_interaction x=interactive);
        hk_presentation* existing_presentation(const hk_string& name, hk_presentation::enum_presentationtype t);
        hk_form* existing_form(const hk_string name);
        hk_report* existing_report(const hk_string name);

        void save(const hk_string& statement,const hk_string& name,filetype type,bool ask_before_overwrite=true,bool ask_for_new_name=false );
        hk_string load(const hk_string& name,filetype type);

        hk_string database_path(void);
        hk_string fileendings(filetype e);
        hk_string fileendings(objecttype e);
        bool copy_table(hk_datasource* fromdatasource,bool schema_and_data,bool replacetable, bool ask,progress_dialogtype* progressdialog=NULL);
        bool copy_view(hk_datasource* fromdatasource,progress_dialogtype* progressdialog=NULL,const hk_string& newname="");

hk_form* new_formvisible(void);
hk_form* new_dialogformvisible(void);
hk_report* new_reportvisible(void);
hk_dstable* new_tablevisible(void);
hk_dsquery* new_queryvisible(void);
static void     set_new_formvisiblefunction(newform_type*);
static void     set_new_dialogformvisiblefunction(newform_type*);
static void     set_new_reportvisiblefunction(newreport_type*);
static void     set_new_tablevisiblefunction(newtable_type*);
static void     set_new_queryvisiblefunction(newquery_type*);
void set_usewidgetparent(hk_class*);
bool rename_table(const hk_string& originalname, const hk_string& newname,enum_interaction x=interactive);
bool rename_file(const hk_string& originalname, const hk_string& newname,filetype type,enum_interaction x=interactive);
void disable(void);

bool store_connectionfile(const hk_url& url, bool store_password=false);


enum enum_storagemode {central,local};
void set_storagemode(filetype, enum_storagemode load,enum_storagemode store);
enum_storagemode storagemode(filetype);
enum_storagemode loadmode(filetype);
bool create_centralstoragetable(void);
bool has_centralstoragetable(void);
hk_string load_local(const hk_string& name,filetype type);
hk_string load_central(const hk_string& name,filetype type);
void save_local(const hk_string& statement,const hk_string& name,filetype type,bool ask_before_overwrite,bool ask_for_new_name);
void save_central(const hk_string& statement,const hk_string& name,filetype type,bool ask_before_overwrite,bool ask_for_new_name);
bool  delete_localfile(const hk_string& name,filetype type,enum_interaction x=interactive);
bool  delete_centralfile(const hk_string& name,filetype type,enum_interaction x=interactive);
vector<hk_string>* filelist(filetype type);
vector<hk_string>* local_filelist(filetype type);
vector<hk_string>* central_filelist(filetype type);

void save_configuration(void);
list <hk_presentation*>* presentationlist() const;


    protected:
        hk_database(hk_connection* c);
        bool    select_db( const hk_string& newname);
        void inform_datasources_before_closing(void);
        virtual  void driver_specific_tablelist(void){}
        virtual  void driver_specific_viewlist(void){}
        virtual hk_datasource* driver_specific_new_table(hk_presentation* p);
        virtual hk_datasource* driver_specific_new_view(hk_presentation* p);
        virtual hk_datasource* driver_specific_new_resultquery(hk_presentation* p);
        virtual hk_actionquery*   driver_specific_new_actionquery(void){return NULL;}
        virtual bool    driver_specific_rename_table(const hk_string& oldname,const hk_string& newname){return false;}
        virtual bool driver_specific_select_db(void){return false;}
        virtual void driver_specific_set_name(void){}
        hk_connection* p_connection;
        void    ds_remove(hk_data* ds);
        virtual void connection_connected(void);
        virtual void connection_disconnected(void);

        vector<hk_string> p_tablelist;
        vector<hk_string> p_viewlist;
        vector<hk_string> p_tableviewlist;
        void    dbvisible_add(hk_dbvisible* v);
        void    dbvisible_remove(hk_dbvisible* v);
        void    clear_visiblelist(void);
        virtual void before_source_vanishes(void);
        void    presentation_add(hk_presentation* p);
        void    presentation_remove(hk_presentation* p);
        void load_configuration(void);
        virtual void savedata(ostream& s);
        virtual void loaddata(const hk_string& definition);
        hk_url p_url;
    private:
        void clear_presentationlist();
        void mark_datasources_as_not_handled(void);
        void mark_visible_objects_as_not_handled(void);
        void inform_datasources_filelist_changes(listtype type);
        hk_databaseprivate* p_private;
        static newform_type *p_newformfunction;
        static newform_type *p_newdialogformfunction;
        static newreport_type *p_newreportfunction;
        static newtable_type *p_newtablefunction;
        static newquery_type *p_newqueryfunction;
        void save_storage(ostream&,filetype);
        void load_storage(const hk_string&,filetype);


} ;
#endif

---