hk_datasource Class Reference

represents a resultquery or a table of a database. More...

#include <hk_datasource.h>

Inheritance diagram for hk_datasource:


Public Types
enum	enum_tablemodes { mode_normal, mode_createtable, mode_altertable, mode_disabled, mode_insertrow, mode_deleterow, mode_unknown }
enum	enum_accessmode { standard, batchread, batchwrite }
enum	enum_dependingmodes { depending_nohandle, depending_standard, depending_change, depending_delete, depending_changedelete }
Public Member Functions
virtual	~hk_datasource ()
virtual void	set_name (const hk_string &n, bool registerchange=true)
virtual hk_string	name (void)
enum_tablemodes	mode (void)
void	setmode_insertrow (void)
void	delete_actualrow (enum_interaction c=interactive)
void	setmode_normal (void)
void	setmode_createtable (void)
void	setmode_altertable (void)
hk_column *	new_column (void)
bool	alter_column (const hk_string &col, const hk_string name=NULL, hk_column::enum_columntype newtype=NULL, long size=NULL, const hk_string defaultvalue=NULL, const bool primary=NULL, const bool notnull=NULL)
bool	delete_column (const hk_string &col)
bool	create_table_now (void)
bool	alter_table_now (void)
bool	create_view_now (void)
bool	alter_view_now (void)
virtual bool	goto_row (unsigned long r)
bool	while_goto_row (void) const
bool	goto_first (void)
bool	goto_last (void)
bool	goto_next (void)
bool	goto_previous (void)
bool	goto_random (void)
unsigned long	row_position (void)
unsigned long	max_rows (void)
bool	set_accessmode (enum_accessmode)
enum_accessmode	accessmode (void) const
bool	enable (void)
bool	while_enabling (void) const
bool	disable (void)
bool	while_disabling (void) const
bool	set_enabled (bool e)
bool	is_enabled (void) const
bool	is_readonly (void) const
void	set_readonly (bool r)
list< hk_column * > *	columns (void)
list< hk_string > *	columnnames (void)
hk_column *	column_by_name (const hk_string &c)
hk_column *	column_by_name (const hk_string &c, int colnumber)
int	columnname_occurances (const hk_string &colname)
int	columnname_occurance (hk_column *)
bool	set_sql (const hk_string &s, bool rawsql=false, bool registerchange=true)
virtual bool	set_query (hk_qbe *, bool registerchange=true)
hk_string	sql (void) const
bool	is_rawsql (void)
hk_string	backendsql (void) const
list< indexclass > *	indices (void)
bool	index_exists (const hk_string &)
bool	drop_index (const hk_string &i)
bool	create_index (const hk_string &name, bool unique, list< hk_string > &fields)
bool	alter_index (const hk_string &name, bool unique, list< hk_string > &fields)
enum_dependingmodes	dependingmode (void)
bool	set_depending_on (hk_datasource *d, bool react_on_data_changes=false, enum_dependingmodes mode=depending_standard)
hk_datasource *	depending_on (void)
bool	depending_on_react_on_data_changes (void)
list< hk_string > *	depending_on_thisfields (void)
list< hk_string > *	depending_on_masterfields (void)
bool	set_depending_on_presentationdatasource (long d, bool react_on_data_changes=false, enum_dependingmodes mode=depending_standard, bool registerchange=true)
long	depending_on_presentationdatasource (void)
void	add_depending_fields (const hk_string &this_ds_field, const hk_string &master_ds_field, bool registerchange=true)
void	clear_depending_fields (bool registerchange=true)
bool	store_changed_data (enum_interaction c=interactive)
void	set_ignore_changed_data (void)
bool	ignore_changed_data (void) const
void	set_filter (const hk_string &f, bool registerchange=true)
hk_string	filter (void)
void	set_temporaryfilter (const hk_string &f)
hk_string	temporaryfilter (void)
void	set_use_temporaryfilter (bool use)
bool	use_temporaryfilter (void)
void	set_internalfilter (const hk_string &f)
hk_string	internalfilter (void)
void	set_use_internalfilter (bool use)
bool	use_internalfilter (void)
void	clear_filter (bool registerchange=true)
void	set_sorting (const hk_string &s, bool registerchange=true)
hk_string	sorting (void)
void	set_temporarysorting (const hk_string &s)
hk_string	temporarysorting (void)
void	set_use_temporarysorting (bool use)
bool	use_temporarysorting (void)
void	clear_sorting (bool registerchange=true)
void	set_automatic_data_update (bool u)
bool	is_automatic_data_update (void)
void	set_sqldelimiter (const hk_string &)
void	set_datetimeformat (const hk_string &datetime, const hk_string &date, const hk_string &time)
hk_database *	database (void)
void	savedata (ostream &s, bool saveall=true)
void	loaddata (const hk_string &definition, bool loadsql=true)
long	presentationnumber (void) const
bool	datasource_used (void) const
virtual void	dump_data ()
bool	ask_name (void)
bool	delete_rows (unsigned long from, unsigned long to, bool check_depending_datasources=true, bool ask=true)
void	transaction_begin (hk_string name="")
void	transaction_commit (hk_string name="")
void	transaction_rollback (hk_string name="")
void	set_blockvisiblesignals (bool v)
bool	blockvisiblesignals (void)
void	set_blockserversignals (bool)
bool	blockserversignals (void)
void	set_blockdatasourcesignals (bool)
bool	blockdatasourcesignals (void)
void	save_datasourcedefinition (ostream &s)
bool	load_datasourcedefinition (const hk_string &definition, bool use_xmltablename=true, bool ask=true)
hk_presentation *	presentation (void)
void	set_position (int x, int y, bool registerchange=true)
void	set_size (int width, int height, bool registerchange=true)
int	x (void) const
int	y (void) const
int	width (void) const
int	height (void) const
void	set_designsize (int w, int h, bool registerchange=true)
int	designwidth () const
int	designheight () const
void	automatic_position_datasource (void)
list< hk_datasource * > *	dependinglist (void)
bool	previous_enable_problems (void) const
list< referentialclass > *	referenceslist (void)
bool	add_reference (const referentialclass &)
bool	drop_reference (const hk_string &)
hk_string	fieldorigin (const hk_string &)
hk_string	totalfieldorigin (const hk_string &)
void	reset_changed_data (void)
bool	has_changed (void) const
hk_string	systemcolumnname (const hk_string &n)
bool	depending_on_datasource_deleterow_ok (void)
bool	depending_on_datasource_before_delete_row (void)
bool	depending_on_datasource_updaterow_ok (void)
bool	check_store_changed_data ()
Static Public Member Functions
static void	set_enablefunction (voidfunction *, long counter)
Protected Member Functions
	hk_datasource (hk_database db, hk_presentation p=NULL)
void	column_remove (hk_column *col)
void	visible_add (hk_dsvisible *v)
void	visible_remove (hk_dsvisible *v)
virtual void	driver_specific_transaction_begin (hk_string)
virtual void	driver_specific_transaction_commit (hk_string)
virtual void	driver_specific_transaction_rollback (hk_string)
virtual unsigned long	driver_specific_max_rows (void)
virtual bool	driver_specific_set_accessmode (enum_accessmode)
virtual bool	driver_specific_batch_enable (void)
virtual bool	driver_specific_batch_disable (void)
virtual bool	driver_specific_batch_goto_next (void)
virtual bool	driver_specific_batch_goto_previous (void)
virtual bool	driver_specific_enable (void)
virtual bool	driver_specific_disable (void)
virtual list< hk_column * > *	driver_specific_columns (void)
virtual bool	driver_specific_goto_row (unsigned long r)
virtual hk_column *	driver_specific_new_column (void)
virtual bool	driver_specific_update_data (void)
virtual bool	driver_specific_delete_data_at (unsigned long)
virtual bool	driver_specific_insert_data (void)
virtual bool	driver_specific_create_table_now (void)
virtual bool	driver_specific_alter_table_now (void)
virtual bool	driver_specific_create_view_now (void)
virtual bool	driver_specific_alter_view_now (void)
virtual void	driver_specific_before_drop_table (void)
virtual void	filelist_changes (listtype t)
virtual list< indexclass > *	driver_specific_indices (void)
virtual bool	driver_specific_drop_index (const hk_string &i)
virtual bool	driver_specific_create_index (const hk_string &name, bool unique, list< hk_string > &fields)
virtual void	before_connection_disconnects (void)
virtual void	before_source_vanishes (void)
virtual void	driver_specific_after_copy_table ()
virtual bool	driver_specific_load_view ()
virtual void	driver_specific_create_viewsql ()
virtual bool	driver_specific_add_reference (const referentialclass &)
virtual bool	driver_specific_drop_reference (const hk_string &)
virtual void	driver_specific_referenceslist (void)
void	depending_ds_add (hk_datasource *d)
void	depending_ds_remove (hk_datasource *d)
void	depending_on_datasource_row_change (bool take_changed_data=false)
void	depending_on_datasource_data_has_changed (void)
void	depending_on_datasource_after_store_changed_data (void)
void	depending_on_datasource_insertmode (void)
void	depending_on_datasource_before_update_row (void)
void	depending_on_datasource_after_update_row (void)
void	reload_data (bool take_changed_data=false)
void	create_actual_row_where_statement (void)
hk_string	create_row_where_statement_at (unsigned long int position, bool withwhere=true)
void	create_new_sql_statement (bool take_changed_data=false)
hk_string	whole_datasource_where_statement (bool take_changed_data=false)
void	print_sql (void)
void	clear_columnlist (void)
void	clear_modecolumnlists (void)
void	clear_visiblelist (void)
void	parse_sql (void)
virtual bool	update_row (enum_interaction c=interactive)
virtual bool	insert_row (enum_interaction c=interactive)
virtual bool	delete_row (enum_interaction c=interactive)
void	parse_fieldpart (void)
void	parse_tablepart (void)
void	set_has_changed (void)
void	set_has_not_changed (void)
hk_string	delimit_identifier (const hk_string &)
void	inform_before_row_change (void)
void	inform_visible_objects_batch_goto_next (void)
void	inform_visible_objects_batch_goto_previous (void)
void	inform_visible_objects_before_store_changed_data (void)
void	inform_visible_objects_after_store_changed_data (void)
void	inform_visible_objects_row_change (void)
void	inform_visible_objects_row_add (void)
void	inform_visible_objects_row_delete (void)
void	inform_visible_objects_before_insert_row (void)
void	inform_before_enable (void)
void	inform_before_disable (void)
void	inform_visible_objects_ds_disable (void)
void	inform_visible_objects_ds_enable (void)
void	inform_depending_ds_goto_row (void)
void	inform_depending_ds_store_data (void)
void	inform_depending_ds_data_has_changed (void)
void	inform_depending_ds_after_store_changed_data (void)
void	inform_depending_ds_before_update_row (void)
void	inform_depending_ds_after_update_row (void)
void	inform_depending_ds_disable (void)
void	inform_depending_ds_enable (void)
void	inform_depending_ds_insertmode (void)
void	inform_visible_objects_new_columns_created (void)
void	inform_visible_objects_before_columns_deleted (void)
void	inform_visible_objects_insertmode (void)
void	inform_when_table_structure_changes (void)
void	inform_when_indexlist_changes (void)
void	execute_visible_object_script_before_update (void)
void	execute_visible_object_script_after_update (void)
void	execute_visible_object_before_row_change (void)
void	execute_visible_object_after_row_change (void)
void	execute_visible_object_before_delete (void)
void	execute_visible_object_after_delete (void)
void	execute_visible_object_before_insert (void)
void	execute_visible_object_after_insert (void)
hk_string	new_referencename (const referentialclass &)
bool	is_newreferencename (const hk_string &)
Protected Attributes
bool	p_casesensitive
bool	p_enabled
bool	p_readonly
bool	p_primary_key_used
bool	p_ignore_changed_data
unsigned long	p_counter
hk_database *	p_database
list< hk_column * > *	p_columns
list< class_altercolumns >	p_altercolumns
list< hk_string >	p_deletecolumns
list< hk_column * >	p_newcolumns
list< hk_string >	depending_this_fields
list< hk_string >	depending_master_fields
struct_parsed_sql *	p_parsed_sql
hk_string	p_sql
hk_string	p_viewsql
hk_string	p_actual_row_where
bool	p_automatic_data_update
hk_actionquery *	p_actionquery
hk_string	p_datetimeformat
hk_string	p_dateformat
hk_string	p_timeformat
hk_string	p_sql_delimiter
hk_string	p_true
hk_string	p_false
bool	p_tablesql_set
list< hk_datasource * >	p_dependinglist
enum_tablemodes	p_mode
list< referentialclass >	p_references
Static Protected Attributes
static voidfunction *	p_enablefunction
static long	p_enablefunctioncounter
Friends
class	hk_column
class	hk_dsvisible
class	hk_database
class	hk_presentation
Classes
class	class_altercolumns
class	fieldoriginclass
class	indexclass
class	struct_parsed_sql

Detailed Description

represents a resultquery or a table of a database.

Version:

Revision: 1.94

Author:: Horst Knorr (hk_classes@knoda.org)

hk_datasource is the basic class which represents a resultquery or a table of a database. Never create this table directly. Use the hk_database::new_table method instead.

Two types of this class can be distinguished. Tables and Resultqueries.

Resultqueries are Queries with a SELECT - SQL-statement. The resulting data cannot be edited or manipulated.

Tables are a special form of resultqueries. The SQL-statement is fixed ("SELECT * FROM <tablename>), but the resulting dataset can be edited.

Member Enumeration Documentation

enum hk_datasource::enum_accessmode

the accessmode regulates the behaviour of the datasource. In mode 'standard' the datasource is readable and writeable, but usually first loads all the data from the SQL server. This is in some cases not necessary. If you just need to serially read one row after another, you can use the 'batchread' mode. In this case random access is not possible and it is not possible to edit the data or insert rows (e.g. this is used in hk_report). In 'batchwrite' mode data can't be read and is only used for inserting data (e.g. used hk_importcsv) The batchmodes do not need as much memory as the standard mode.
Enumeration values:

standard

batchread

batchwrite

enum hk_datasource::enum_dependingmodes

See dependingmode for details
Enumeration values:

depending_nohandle

depending_standard

depending_change

depending_delete

depending_changedelete

enum hk_datasource::enum_tablemodes

Enumeration values:

mode_normal

mode_createtable

mode_altertable

mode_disabled

mode_insertrow

mode_deleterow

mode_unknown

Constructor & Destructor Documentation

virtual hk_datasource::~hk_datasource ( ) [virtual]

hk_datasource::hk_datasource ( hk_database * db,

hk_presentation * p = NULL

) [protected]

Member Function Documentation

enum_accessmode hk_datasource::accessmode ( void ) const

void hk_datasource::add_depending_fields ( const hk_string & this_ds_field,

const hk_string & master_ds_field,

bool registerchange = true

)

use this method in connection with depending_on.
Parameters:

this_ds_field fieldname of a column of this datasource which has to be connected to the master datasource.

master_ds_field columnname of the masterdatasource which value has to be equal with the value of this_ds_field.

registerchange if this class is part of a hk_presentation object (i.e. a form or a report) and registerchange is true, then the changes will be stored when the hk_presentation object is closed.

bool hk_datasource::add_reference ( const referentialclass & )

will try to add a new reference to a table

bool hk_datasource::alter_column ( const hk_string & col,

const hk_string * name = NULL,

hk_column::enum_columntype * newtype = NULL,

long * size = NULL,

const hk_string * defaultvalue = NULL,

const bool * primary = NULL,

const bool * notnull = NULL

)

if this datasource is of type "table" and in mode "alter" you can alter an existing column. NULL values mean, that this part will not be changed

bool hk_datasource::alter_index ( const hk_string & name,

bool unique,

list< hk_string > & fields

)

Alters an existing index by first dropping it with drop_index and then by trying to recreate it with create_index

bool hk_datasource::alter_table_now ( void )

After altering an existing table with setmode_altertable, new_column ,alter_column and delete_column this function alters physically the table

bool hk_datasource::alter_view_now ( void )

bool hk_datasource::ask_name ( void )

asks interactively for a name

void hk_datasource::automatic_position_datasource ( void )

hk_string hk_datasource::backendsql ( void ) const

returns the SQL statement as it is sent to the SQL server

virtual void hk_datasource::before_connection_disconnects ( void ) [protected, virtual]

Reimplemented from hk_data.

virtual void hk_datasource::before_source_vanishes ( void ) [protected, virtual]

Reimplemented from hk_data.

bool hk_datasource::blockdatasourcesignals ( void )

bool hk_datasource::blockserversignals ( void )

bool hk_datasource::blockvisiblesignals ( void )

bool hk_datasource::check_store_changed_data ( )

void hk_datasource::clear_columnlist ( void ) [protected]

void hk_datasource::clear_depending_fields ( bool registerchange = true )

clears the depending list.

void hk_datasource::clear_filter ( bool registerchange = true )

clears the filter which was set with set_filter
Parameters:

registerchange if this class is part of a hk_presentation object (i.e. a form or a report) and registerchange is true, then the changes will be stored when the hk_presentation object is closed.

void hk_datasource::clear_modecolumnlists ( void ) [protected]

void hk_datasource::clear_sorting ( bool registerchange = true )

clears the sorting instruction
Parameters:

registerchange if this class is part of a hk_presentation object (i.e. a form or a report) and registerchange is true, then the changes will be stored when the hk_presentation object is closed.

void hk_datasource::clear_visiblelist ( void ) [protected]

hk_column* hk_datasource::column_by_name ( const hk_string & c,

int colnumber

)

if the datasource is enabled, you can reach a particular column by name.
Parameters:

colnumber If there are more than 1 columns with the same name this parameter tells which one to take (1 is the first column)

Returns:
hk_column if there is a column with this name else NULL.

hk_column* hk_datasource::column_by_name ( const hk_string & c )

if the datasource is enabled, you can reach a particular column by name
Returns:
hk_column if there is a column with this name else NULL.

void hk_datasource::column_remove ( hk_column * col ) [protected]

int hk_datasource::columnname_occurance ( hk_column * )

returns if this is the first, second ... nth column with this name

int hk_datasource::columnname_occurances ( const hk_string & colname )

returns how many columns exist in this datasource with the name 'colname'. Usually columnnames should be unique, but it is unfortunately technically possible to create SQL statements that return ambigous columnnames

list<hk_string>* hk_datasource::columnnames ( void )

list<hk_column*>* hk_datasource::columns ( void )

if the datasource is enabled you get a list of all columns. The fields can be reached by columns. See hk_column for details. returns NULL if no columns are defined yet (e.g. non-enabled queries)

void hk_datasource::create_actual_row_where_statement ( void ) [protected]

bool hk_datasource::create_index ( const hk_string & name,

bool unique,

list< hk_string > & fields

)

creates an index of a table. returns true if successful otherwise false; make sure you have set the tablename first.
Parameters:

name new name of the index

unique true if this should be a unique index

fields the field(column) names used by this index

Returns:
true if successful otherwise false;

void hk_datasource::create_new_sql_statement ( bool take_changed_data = false ) [protected]

hk_string hk_datasource::create_row_where_statement_at ( unsigned long int position,

bool withwhere = true

) [protected]

bool hk_datasource::create_table_now ( void )

After defining a new table with setmode_createtable and new_column this function creates physically the table

bool hk_datasource::create_view_now ( void )

hk_database* hk_datasource::database ( void )

bool hk_datasource::datasource_used ( void ) const

Returns:
true if a hk_visible object or a depending datasource is using this datasource else false

void hk_datasource::delete_actualrow ( enum_interaction c = interactive )

this function tries to delete the actual row. If there is a depending datasource with equivalent rows the actual row will not be deleted.

bool hk_datasource::delete_column ( const hk_string & col )

if this datasource is of type "table" and in mode "alter" you can delete an existing column.Just enter the name here.

virtual bool hk_datasource::delete_row ( enum_interaction c = interactive ) [protected, virtual]

bool hk_datasource::delete_rows ( unsigned long from,

unsigned long to,

bool check_depending_datasources = true,

bool ask = true

)

Delete rows beginning from row number "from" to row number "to"

hk_string hk_datasource::delimit_identifier ( const hk_string & ) [protected]

void hk_datasource::depending_ds_add ( hk_datasource * d ) [protected]

void hk_datasource::depending_ds_remove ( hk_datasource * d ) [protected]

hk_datasource* hk_datasource::depending_on ( void )

void hk_datasource::depending_on_datasource_after_store_changed_data ( void ) [protected]

void hk_datasource::depending_on_datasource_after_update_row ( void ) [protected]

bool hk_datasource::depending_on_datasource_before_delete_row ( void )

void hk_datasource::depending_on_datasource_before_update_row ( void ) [protected]

void hk_datasource::depending_on_datasource_data_has_changed ( void ) [protected]

bool hk_datasource::depending_on_datasource_deleterow_ok ( void )

void hk_datasource::depending_on_datasource_insertmode ( void ) [protected]

void hk_datasource::depending_on_datasource_row_change ( bool take_changed_data = false ) [protected]

bool hk_datasource::depending_on_datasource_updaterow_ok ( void )

list<hk_string>* hk_datasource::depending_on_masterfields ( void )

a list of the depending on columns of the master datasource set with add_depending_fields

long hk_datasource::depending_on_presentationdatasource ( void )

bool hk_datasource::depending_on_react_on_data_changes ( void )

See dependingmode for details

list<hk_string>* hk_datasource::depending_on_thisfields ( void )

a list of the depending on columns of this datasource set with add_depending_fields

list<hk_datasource*>* hk_datasource::dependinglist ( void )

enum_dependingmodes hk_datasource::dependingmode ( void )

depending_nohandle = ignore that this is a depending datasource depending_standard = can't delete a master row when there are depending rows in the depending datasource and can't change the value of a master connection field. depending_change = if a master connection field is changed, the equivalent depending fields will change their values too. depending_delete = if the master row is deleted the depending rows will also be deleted depending_changedelete = combination of depending_change and depending_delete
See also set_depending_on for details

int hk_datasource::designheight ( ) const

int hk_datasource::designwidth ( ) const

bool hk_datasource::disable ( void )

if the datasource is enabled, this function will disable it. The columnlist will be deleted.

virtual bool hk_datasource::driver_specific_add_reference ( const referentialclass & ) [protected, virtual]

virtual void hk_datasource::driver_specific_after_copy_table ( ) [inline, protected, virtual]

will be called from hk_database

virtual bool hk_datasource::driver_specific_alter_table_now ( void ) [inline, protected, virtual]

virtual bool hk_datasource::driver_specific_alter_view_now ( void ) [protected, virtual]

virtual bool hk_datasource::driver_specific_batch_disable ( void ) [inline, protected, virtual]

virtual bool hk_datasource::driver_specific_batch_enable ( void ) [inline, protected, virtual]

virtual bool hk_datasource::driver_specific_batch_goto_next ( void ) [inline, protected, virtual]

virtual bool hk_datasource::driver_specific_batch_goto_previous ( void ) [inline, protected, virtual]

virtual void hk_datasource::driver_specific_before_drop_table ( void ) [inline, protected, virtual]

virtual list<hk_column*>* hk_datasource::driver_specific_columns ( void ) [inline, protected, virtual]

returns a list of the columns of the datasource. If the datasource is a table the list hast to be created even if the datasource is disabled. Fill the p_columns list for this reason and then return it. If necessary has to create one hk_column object per column and to add them to p_columns. Each column object has to get a unique number in its (protected) hk_column::p_fieldnr .

virtual bool hk_datasource::driver_specific_create_index ( const hk_string & name,

bool unique,

list< hk_string > & fields

) [protected, virtual]

virtual bool hk_datasource::driver_specific_create_table_now ( void ) [inline, protected, virtual]

virtual bool hk_datasource::driver_specific_create_view_now ( void ) [protected, virtual]

virtual void hk_datasource::driver_specific_create_viewsql ( ) [inline, protected, virtual]

virtual bool hk_datasource::driver_specific_delete_data_at ( unsigned long ) [inline, protected, virtual]

virtual bool hk_datasource::driver_specific_disable ( void ) [inline, protected, virtual]

virtual bool hk_datasource::driver_specific_drop_index ( const hk_string & i ) [protected, virtual]

virtual bool hk_datasource::driver_specific_drop_reference ( const hk_string & ) [protected, virtual]

virtual bool hk_datasource::driver_specific_enable ( void ) [inline, protected, virtual]

has to make sure that the columns-list has been created. It also has to provide access to the data of the datasource

virtual bool hk_datasource::driver_specific_goto_row ( unsigned long r ) [protected, virtual]

virtual list<indexclass>* hk_datasource::driver_specific_indices ( void ) [inline, protected, virtual]

virtual bool hk_datasource::driver_specific_insert_data ( void ) [inline, protected, virtual]

virtual bool hk_datasource::driver_specific_load_view ( ) [inline, protected, virtual]

virtual unsigned long hk_datasource::driver_specific_max_rows ( void ) [inline, protected, virtual]

virtual hk_column* hk_datasource::driver_specific_new_column ( void ) [inline, protected, virtual]

virtual void hk_datasource::driver_specific_referenceslist ( void ) [protected, virtual]

virtual bool hk_datasource::driver_specific_set_accessmode ( enum_accessmode ) [inline, protected, virtual]

virtual void hk_datasource::driver_specific_transaction_begin ( hk_string ) [protected, virtual]

virtual void hk_datasource::driver_specific_transaction_commit ( hk_string ) [protected, virtual]

virtual void hk_datasource::driver_specific_transaction_rollback ( hk_string ) [protected, virtual]

virtual bool hk_datasource::driver_specific_update_data ( void ) [inline, protected, virtual]

bool hk_datasource::drop_index ( const hk_string & i )

deletes an index of a table. returns true if successful otherwise false;
Parameters:

i name of the index

bool hk_datasource::drop_reference ( const hk_string & )

virtual void hk_datasource::dump_data ( ) [virtual]

bool hk_datasource::enable ( void )

if hk_connection is connected, this method will enable the datasource. The SQL-Statement in SQL will be executed. If the SQL-statement is ok, the resulting data can be reached via the columns in columns. You can browse the data by using the methods goto_row, goto_first, goto_last, goto_next and goto_previous.
Returns:
true if enable was successful.

void hk_datasource::execute_visible_object_after_delete ( void ) [protected]

void hk_datasource::execute_visible_object_after_insert ( void ) [protected]

void hk_datasource::execute_visible_object_after_row_change ( void ) [protected]

void hk_datasource::execute_visible_object_before_delete ( void ) [protected]

void hk_datasource::execute_visible_object_before_insert ( void ) [protected]

void hk_datasource::execute_visible_object_before_row_change ( void ) [protected]

void hk_datasource::execute_visible_object_script_after_update ( void ) [protected]

void hk_datasource::execute_visible_object_script_before_update ( void ) [protected]

hk_string hk_datasource::fieldorigin ( const hk_string & )

virtual void hk_datasource::filelist_changes ( listtype t ) [protected, virtual]

Reimplemented from hk_data.

hk_string hk_datasource::filter ( void )

bool hk_datasource::goto_first ( void )

move the row selector to the first row. All depending objects will be informed (visible objects, depending datasources etc)
Returns:
true if success, else false.

bool hk_datasource::goto_last ( void )

move the row selector to the last row. All depending objects will be informed (visible objects, depending datasources etc)
Returns:
true if success, else false.

bool hk_datasource::goto_next ( void )

move the row selector to the next row. All depending objects will be informed (visible objects, depending datasources etc)
Returns:
true if success, else false.

bool hk_datasource::goto_previous ( void )

move the row selector to the previous row. All depending objects will be informed (visible objects, depending datasources etc)
Returns:
true if success, else false.

bool hk_datasource::goto_random ( void )

moves the rowselector to a random row.

virtual bool hk_datasource::goto_row ( unsigned long r ) [virtual]

Goto a specific row. The first row number is 0, the last n-1 where n is the number of rows as delivered from max_rows().All depending objects will be informed (visible objects, depending datasources etc)
Parameters:

r is the wished new row number to go.

Returns:
true if success, else false.

bool hk_datasource::has_changed ( void ) const

int hk_datasource::height ( void ) const

bool hk_datasource::ignore_changed_data ( void ) const

bool hk_datasource::index_exists ( const hk_string & )

list<indexclass>* hk_datasource::indices ( void )

returns the list of all existing indices of a table or NULL in case of an error (i.e. not a table)

void hk_datasource::inform_before_disable ( void ) [protected]

void hk_datasource::inform_before_enable ( void ) [protected]

void hk_datasource::inform_before_row_change ( void ) [protected]

void hk_datasource::inform_depending_ds_after_store_changed_data ( void ) [protected]

void hk_datasource::inform_depending_ds_after_update_row ( void ) [protected]

void hk_datasource::inform_depending_ds_before_update_row ( void ) [protected]

void hk_datasource::inform_depending_ds_data_has_changed ( void ) [protected]

void hk_datasource::inform_depending_ds_disable ( void ) [protected]

void hk_datasource::inform_depending_ds_enable ( void ) [protected]

void hk_datasource::inform_depending_ds_goto_row ( void ) [protected]

void hk_datasource::inform_depending_ds_insertmode ( void ) [protected]

void hk_datasource::inform_depending_ds_store_data ( void ) [protected]

void hk_datasource::inform_visible_objects_after_store_changed_data ( void ) [protected]

void hk_datasource::inform_visible_objects_batch_goto_next ( void ) [protected]

void hk_datasource::inform_visible_objects_batch_goto_previous ( void ) [protected]

void hk_datasource::inform_visible_objects_before_columns_deleted ( void ) [protected]

void hk_datasource::inform_visible_objects_before_insert_row ( void ) [protected]

void hk_datasource::inform_visible_objects_before_store_changed_data ( void ) [protected]

void hk_datasource::inform_visible_objects_ds_disable ( void ) [protected]

void hk_datasource::inform_visible_objects_ds_enable ( void ) [protected]

void hk_datasource::inform_visible_objects_insertmode ( void ) [protected]

void hk_datasource::inform_visible_objects_new_columns_created ( void ) [protected]

void hk_datasource::inform_visible_objects_row_add ( void ) [protected]

void hk_datasource::inform_visible_objects_row_change ( void ) [protected]

void hk_datasource::inform_visible_objects_row_delete ( void ) [protected]

void hk_datasource::inform_when_indexlist_changes ( void ) [protected]

void hk_datasource::inform_when_table_structure_changes ( void ) [protected]

virtual bool hk_datasource::insert_row ( enum_interaction c = interactive ) [protected, virtual]

hk_string hk_datasource::internalfilter ( void )

bool hk_datasource::is_automatic_data_update ( void )

bool hk_datasource::is_enabled ( void ) const

shows whether the datasource is enabled.

bool hk_datasource::is_newreferencename ( const hk_string & ) [protected]

bool hk_datasource::is_rawsql ( void )

bool hk_datasource::is_readonly ( void ) const

Returns:
true if data in this datasource can be changed. Always false if this datasource is a dml_query.

bool hk_datasource::load_datasourcedefinition ( const hk_string & definition,

bool use_xmltablename = true,

bool ask = true

)

loads the structure of the datasource (fields,indices) in an xml format file and creates the tableand is database driver independent

void hk_datasource::loaddata ( const hk_string & definition,

bool loadsql = true

)

loads the object's values out of the definition string.

unsigned long hk_datasource::max_rows ( void )

number of rows in this query.

enum_tablemodes hk_datasource::mode ( void )

if this datasource is a table, it can be in different "modes". For example if you want to create a new table and define the different columns, the table has to be in "mode_create" See enum_tablemodes for the different modetypes.

virtual hk_string hk_datasource::name ( void ) [virtual]

hk_column* hk_datasource::new_column ( void )

if this datasource is of type "table" and in mode "create" or "alter" you can create a new column to define its parameters.

hk_string hk_datasource::new_referencename ( const referentialclass & ) [protected]

void hk_datasource::parse_fieldpart ( void ) [protected]

void hk_datasource::parse_sql ( void ) [protected]

void hk_datasource::parse_tablepart ( void ) [protected]

hk_presentation* hk_datasource::presentation ( void )

long hk_datasource::presentationnumber ( void ) const [inline]

if the datasource is part of a hk_presentation each datasource gets a unique datasource number as an identifier
Returns:
the unique datasource number if part of a presenation else -1

bool hk_datasource::previous_enable_problems ( void ) const

returns true, if this datasource could not be enabled last time when tried

void hk_datasource::print_sql ( void ) [protected]

list<referentialclass>* hk_datasource::referenceslist ( void )

void hk_datasource::reload_data ( bool take_changed_data = false ) [protected]

void hk_datasource::reset_changed_data ( void )

unsigned long hk_datasource::row_position ( void )

number of the current row.

void hk_datasource::save_datasourcedefinition ( ostream & s )

stores the structure of the datasource (fields,indices) in an xml format file and is database driver independent

void hk_datasource::savedata ( ostream & s,

bool saveall = true

)

stores the object's values to stream s. The following tags will be used
<TYPE> either QUERY or TABLE
<DATASOURCENAME> the name set with set_name
<SQL> the used sql statement
Additionally the section <DATASOURCEEXTRA> has the following tags
<FILTER> the filter set with set_filter
<SORTING> the sorting direction set with set_sorting
<DATETIMEFORMAT>
<DATEFORMAT>
<TIMEFORMAT>
if this datasource is part of a hk_presentation also the following tags will be stored
<UPN> the unique presentation number. See presentationnumber
<DEPENDING_ON> the depending on datasource set with set_depending_on_presentationdatasource
one or more <DEPENDINGFIELDS> sections with the following tags
<THISFIELD> set with add_depending_fields
<MASTERFIELD> set with add_depending_fields

Parameters:

s the stream to which the data will be written

saveall if true the section <DATASOURCEEXTRA> will be stored additionally to the normal data

bool hk_datasource::set_accessmode ( enum_accessmode )

void hk_datasource::set_automatic_data_update ( bool u )

when data has changed and the row selector is moved to another row, usually the datasource will be automatically updated. If the value is set to false, you have to update the data manually by calling store_changed_data.
Parameters:

u If you don't want the automatic update of data changes, set this paramter to false. The default value is true.

void hk_datasource::set_blockdatasourcesignals ( bool )

if true no depending datasources will be informed when data changes in any kind Default is false

void hk_datasource::set_blockserversignals ( bool )

if true no data will be sent to the database server when data changes in any kind Default is false

void hk_datasource::set_blockvisiblesignals ( bool v )

if true no visual objects will be informed when data changes in any kind, except the datasource will be deleted Default is false

void hk_datasource::set_datetimeformat ( const hk_string & datetime,

const hk_string & date,

const hk_string & time

) [inline]

sets the default date and timeformats for new created columns

bool hk_datasource::set_depending_on ( hk_datasource * d,

bool react_on_data_changes = false,

enum_dependingmodes mode = depending_standard

)

if there are 2 datasources in a 1:n relation it is possible to connect the 2 datasources. Add the master datasource here ( it's the '1'-datasource in the '1:n'-relation). Except of the master datasource you also have to add the connected fields with add_depending_fields This (the depending) datasource will enable/disable automatically when the master datasource will enable/disable. if this datasource is part of a hk_presentation use set_depending_on_presentationdatasource instead
Parameters:

d is the master datasource

react_on_data_changes true if the datasource should react when a value of the masterdatasource is changed but not yet stored

mode how to react when the masterdatasource changes its data. See enum_dependingmodes for details.

bool hk_datasource::set_depending_on_presentationdatasource ( long d,

bool react_on_data_changes = false,

enum_dependingmodes mode = depending_standard,

bool registerchange = true

)

if this datasource is part of a hk_presentation object (form or report) then set the depending on datasource with this function. You can get the unique datasource number of a datasource with presentationnumber
Parameters:

d the presentationnumber of the master datasource

registerchange if this class is part of a hk_presentation object (i.e. a form or a report) and registerchange is true, then the changes will be stored when the hk_presentation object is closed.

void hk_datasource::set_designsize ( int w,

int h,

bool registerchange = true

)

bool hk_datasource::set_enabled ( bool e )

convenience function: if e is true the datasource will be enabled by calling enable else it will disable the datasource by calling disable.

static void hk_datasource::set_enablefunction ( voidfunction * ,

long counter

) [static]

void hk_datasource::set_filter ( const hk_string & f,

bool registerchange = true

)

it is possible to filter only specific rows from a datasource by setting this filter. just add the conditions with this function.
Parameters:

f same syntax as a SQL statement in the 'WHERE' section, but without the word 'WHERE'

registerchange if this class is part of a hk_presentation object (i.e. a form or a report) and registerchange is true, then the changes will be stored when the hk_presentation object is closed. Example: SELECT * from addresses WHERE city="Mnchen", so you would call set_filter("city=\"Mnchen\"");

void hk_datasource::set_has_changed ( void ) [protected]

void hk_datasource::set_has_not_changed ( void ) [protected]

void hk_datasource::set_ignore_changed_data ( void )

void hk_datasource::set_internalfilter ( const hk_string & f )

virtual void hk_datasource::set_name ( const hk_string & n,

bool registerchange = true

) [virtual]

sets the name of the datasource
Parameters:

n the name

registerchange if this class is part of a hk_presentation object (i.e. a form or a report) and registerchange is true, then the changes will be stored when the hk_presentation object is closed.

void hk_datasource::set_position ( int x,

int y,

bool registerchange = true

)

the position will be used for the database designer GUI. Mostly you don't have to manipulate the values

virtual bool hk_datasource::set_query ( hk_qbe * ,

bool registerchange = true

) [virtual]

void hk_datasource::set_readonly ( bool r )

If the datasource is of type ds_table you can allow or disallow data changes.

void hk_datasource::set_size ( int width,

int height,

bool registerchange = true

)

the size will be used for the database designer GUI. Mostly you don't have to manipulate the values

void hk_datasource::set_sorting ( const hk_string & s,

bool registerchange = true

)

it is possible to sort the datasource. just add the conditions with this function.
Parameters:

f same syntax as a SQL statement in the "ORDER BY" section, but without the word "ORDER BY"

registerchange if this class is part of a hk_presentation object (i.e. a form or a report) and registerchange is true, then the changes will be stored when the hk_presentation object is closed. Example: SELECT * from addresses ORDER BY city DESC , so you would call set_sorting("city DESC");

bool hk_datasource::set_sql ( const hk_string & s,

bool rawsql = false,

bool registerchange = true

)

set your own SQL statement, that will be executed when you enable the datasource. if this datasource is of type "table" it will be automatically created.
Parameters:

s is the sql statement

rawsql if true the sql statement will used as is (otherwise it may be changed )

registerchange if this class is part of a hk_presentation object (i.e. a form or a report) and registerchange is true, then the changes will be stored when the hk_presentation object is closed. sorting, filtering or depending on statements). So it is possible to execute driver specific result queries which do not contain the "SELECT" statement, i.e. SHOW FIELDS in Mysql.

void hk_datasource::set_sqldelimiter ( const hk_string & )

void hk_datasource::set_temporaryfilter ( const hk_string & f )

temporary filters just work like filters (see set_filter ), but have to be manually activated with set_use_temporaryfilter. When loaded with loaddata temporaryfilters are deactivated by default.

void hk_datasource::set_temporarysorting ( const hk_string & s )

void hk_datasource::set_use_internalfilter ( bool use )

void hk_datasource::set_use_temporaryfilter ( bool use )

void hk_datasource::set_use_temporarysorting ( bool use )

void hk_datasource::setmode_altertable ( void )

If you want to alter an existing table first bring the table in altermode. Define new columns with new_column. Alter it with alter_column and delete a column by calling alter_column. Afterwards you can alter the table by calling alter_table_now

void hk_datasource::setmode_createtable ( void )

If you want to create a new table first bring the table in createmode. Define new columns with new_column. Afterwards you can create the table by calling create_table_now

void hk_datasource::setmode_insertrow ( void )

brings the datasource in insertmode. To add a new row call this function, set the data of the new row as usual in the columns (i.e.with hk_column::as_string ) and finally call either setmode_normal or store_changed_data.

void hk_datasource::setmode_normal ( void )

This is the usual mode, where you can browse the data and if the data is not readonly change the data.

hk_string hk_datasource::sorting ( void )

hk_string hk_datasource::sql ( void ) const

bool hk_datasource::store_changed_data ( enum_interaction c = interactive )

if the data of the actual row has changed you can manually send the changes to the SQL Server by calling this function. The function will be called automatically before the datasource disables or the row selector will be moved to another row.

hk_string hk_datasource::systemcolumnname ( const hk_string & n )

returns a transformed column name in case the driver does only support e.g. ASCII characters

hk_string hk_datasource::temporaryfilter ( void )

hk_string hk_datasource::temporarysorting ( void )

hk_string hk_datasource::totalfieldorigin ( const hk_string & )

void hk_datasource::transaction_begin ( hk_string name = "" )

Start a transaction. If the SQL server does not support transaction this function does nothing
Parameters:

name the name of the transaction

void hk_datasource::transaction_commit ( hk_string name = "" )

Commits a transaction. If the SQL server does not support transaction this function does nothing
Parameters:

name the name of the transaction

void hk_datasource::transaction_rollback ( hk_string name = "" )

Undo a transaction. If the SQL server does not support transaction this function does nothing
Parameters:

name the name of the transaction

virtual bool hk_datasource::update_row ( enum_interaction c = interactive ) [protected, virtual]

bool hk_datasource::use_internalfilter ( void )

bool hk_datasource::use_temporaryfilter ( void )

bool hk_datasource::use_temporarysorting ( void )

void hk_datasource::visible_add ( hk_dsvisible * v ) [protected]

void hk_datasource::visible_remove ( hk_dsvisible * v ) [protected]

bool hk_datasource::while_disabling ( void ) const

bool hk_datasource::while_enabling ( void ) const

bool hk_datasource::while_goto_row ( void ) const

hk_string hk_datasource::whole_datasource_where_statement ( bool take_changed_data = false ) [protected]

int hk_datasource::width ( void ) const

int hk_datasource::x ( void ) const

int hk_datasource::y ( void ) const

Friends And Related Function Documentation

friend class hk_column [friend]

friend class hk_database [friend]

Reimplemented from hk_data.

friend class hk_dsvisible [friend]

friend class hk_presentation [friend]

Member Data Documentation

list<hk_string> hk_datasource::depending_master_fields [protected]

list<hk_string> hk_datasource::depending_this_fields [protected]

hk_actionquery* hk_datasource::p_actionquery [protected]

hk_string hk_datasource::p_actual_row_where [protected]

list<class_altercolumns> hk_datasource::p_altercolumns [protected]

bool hk_datasource::p_automatic_data_update [protected]

bool hk_datasource::p_casesensitive [protected]

if database driver supports cassensitive column and table names p_casesensitive is true else p_casesensitive is false. Then internally column_by_name() and name() return values in small letters