hk_column Class Reference

represents one column of a datasource. More...

#include <hk_column.h>

Inheritance diagram for hk_column:


Public Types
enum	enum_columntype { textcolumn, auto_inccolumn, smallintegercolumn, integercolumn, smallfloatingcolumn, floatingcolumn, datecolumn, datetimecolumn, timecolumn, timestampcolumn, binarycolumn, memocolumn, boolcolumn, othercolumn }
Public Member Functions
hk_string	name (void) const
void	set_name (const hk_string &n)
bool	is_readonly (void) const
void	set_readonly (bool r)
enum_columntype	columntype (void) const
void	set_columntype (enum_columntype f)
long	size (void)
void	set_size (long s)
hk_string	columntype_name (void)
bool	is_primary (void)
bool	set_primary (bool i)
bool	is_notnull (void)
hk_string	get_delimiter (void)
bool	set_notnull (bool i)
bool	has_changed (void)
hk_string	asstring (bool as_locale=true)
void	set_asstring (const hk_string &s, bool registerchange=true)
void	set_asstring (const hk_string &s, bool registerchange, bool is_locale)
const char *	transformed_asstring (void)
const char *	transformed_asstring_at (unsigned long position)
hk_string	changed_data_asstring (bool as_locale=true)
void	set_asbinary (const struct_raw_data *rd)
const struct_raw_data *	asbinary (void)
const struct_raw_data *	asbinary_at (unsigned long a)
void	set_asbool (bool b)
bool	asbool (void)
bool	asbool_at (unsigned long a)
bool	changed_data_asbool (void)
void	set_asinteger (long int s, bool registerchange=true)
long int	asinteger (void)
long int	asinteger_at (unsigned long)
long int	changed_data_asinteger (void)
void	set_asdouble (double s, bool registerchange=true)
double	asdouble (void)
double	asdouble_at (unsigned long)
double	changed_data_asdouble (void)
unsigned int	fieldnumber (void)
hk_string	asstring_at (unsigned long a, bool as_locale=true)
bool	is_nullvalue (void)
bool	changed_data_is_nullvalue (void)
bool	is_nullvalue_at (unsigned long a)
void	set_asnullvalue (bool registerchange=true)
long int	count (unsigned int from, unsigned int to)
double	sum (unsigned int from, unsigned int to)
long int	count ()
double	sum ()
unsigned int	find (unsigned int from, unsigned int to, const hk_string &searchtext, bool wholephrase=false, bool casesensitive=false, bool backwards=false)
unsigned int	find (const hk_string &searchtext, bool wholephrase=false, bool casesensitive=false, bool backwards=false)
bool	is_findstring (unsigned int pos, const hk_string &searchtext, bool wholephrase=false, bool casesensitive=false)
const struct_raw_data *	changed_data (void)
const struct_raw_data *	transformed_changed_data (void)
void	reset_changed_data (void)
void	set_boolvalues (const hk_string &TRUESTRING, const hk_string &FALSESTRING)
hk_string	bool_truevalue (void)
hk_string	bool_falsevalue (void)
void	set_dateformat (const hk_string &df)
void	set_timeformat (const hk_string &tf)
void	set_datetimeformat (const hk_string &dtf)
bool	save_to_file (const hk_string &filename)
bool	load_from_file (const hk_string &filename)
void	save_columndefinition (ostream &)
void	load_columndefinition (const hk_string &)
hk_datasource *	datasource (void)
void	set_allow_autoincwrite (bool r)
bool	allow_autoincwrite (void)
bool	in_definitionmode (void)
hk_string	curval_asstring (void)
double	curval_asdouble (void)
long int	curval_asinteger (void)
bool	curval_asbool (void)
void	set_definitionmode (bool def)
hk_string	tableorigin (void)
Protected Member Functions
	hk_column (hk_datasource *ds, const hk_string &TRUESTRING, const hk_string &FALSESTRING)
virtual	~hk_column ()
virtual bool	driver_specific_asstring (const hk_string &d)
virtual hk_string	driver_specific_asstring_at (unsigned long a)
virtual const char *	driver_specific_transformed_asstring_at (unsigned long)
virtual const struct_raw_data *	driver_specific_asbinary_at (unsigned long a)
virtual bool	driver_specific_asbinary (const char *b)
virtual void	driver_specific_asbool (bool b)
virtual bool	driver_specific_asbool_at (unsigned long a)
virtual bool	driver_specific_is_nullvalue_at (unsigned long)
virtual void	data_has_changed (void)
void	datavisible_add (hk_dsdatavisible *)
void	datavisible_remove (hk_dsdatavisible *)
Protected Attributes
hk_datasource *	p_datasource
unsigned int	p_fieldnr
bool	p_readonly
bool	p_driver_specific_delimit_bool
unsigned long	p_driver_specific_data_size
char *	p_driver_specific_data
char *	p_original_new_data
unsigned long	p_original_new_data_size
hk_string	p_sqltextdelimiter
hk_string	p_sqlnulldelimiter
hk_string	p_new_data_asstring
hk_string	p_true
hk_string	p_false
hk_string	p_dateformat
hk_string	p_timeformat
hk_string	p_datetimeformat
hk_string	p_driverspecific_dateformat
hk_string	p_driverspecific_timeformat
hk_string	p_driverspecific_datetimeformat
hk_string	p_driverspecific_timestampformat
hk_string	p_driverspecific_locale
int	p_driverspecific_digits
Friends
class	hk_datasource
class	hk_dsdatavisible

Detailed Description

represents one column of a datasource.

Version:

Revision: 1.52

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

represents one column of a datasource. The data of the current row (set in hk_datasource) can be modified by using the functions set_asstring, set_asbool and set_asbinary and read by using the functions asstring, asbool and asbinary.

If the the datasource is in alter or create mode you can change the column definition by using the following functions: set_name, set_columntype, set_size, set_notnull, set_primary

Member Enumeration Documentation

enum hk_column::enum_columntype

used from hk_column to define of what type it is. For details how the different column types are interpreted look up the documentation of your database server and the database driver.
textcolumn : fixed length (usually in SQL defined as CHAR(size))
auto_inccolumn: if the databasedriver supports this columntype it will get a unique number automatically, whenever a new row will be added. Usually a readonly column
smallintegercolumn: a integer range of at least -32768 to 32767
integercolumn: a integer with the maximum range the database server can handle
smallfloatingcolumn: a floating column with a range of at least ????
floatingcolumn: a floating column with the maximum range the database server can handle
datecolumn: a column to keep the day,month and year of a date
datetimecolumn: a column to keep the day,month and year of a date PLUS the hour,minute and second of a time
timecolumn: a column to keep the hour,minute and second of a time.
binarycolumn: a column to store binary data of more or less any size.
memocolumn: a column to store text data of more or less any size.
boolcolumn: a column that has 2 states 'true' or 'false'
othercolumn: a column hk_classes does not know, but tries to handle as good as it can.
Enumeration values:

textcolumn

auto_inccolumn

smallintegercolumn

integercolumn

smallfloatingcolumn

floatingcolumn

datecolumn

datetimecolumn

timecolumn

timestampcolumn

binarycolumn

memocolumn

boolcolumn

othercolumn

Constructor & Destructor Documentation

hk_column::hk_column ( hk_datasource * ds,

const hk_string & TRUESTRING,

const hk_string & FALSESTRING

) [protected]

virtual hk_column::~hk_column ( ) [protected, virtual]

Member Function Documentation

bool hk_column::allow_autoincwrite ( void )

const struct_raw_data* hk_column::asbinary ( void )

returns the value of the column as raw data.
See also:
save_to_file.

const struct_raw_data* hk_column::asbinary_at ( unsigned long a )

returns the value of the column at a specific rowposition as raw data.

bool hk_column::asbool ( void )

returns the value of this column, type converted to a bool. (All columntypes except Binary).

bool hk_column::asbool_at ( unsigned long a )

double hk_column::asdouble ( void )

double hk_column::asdouble_at ( unsigned long )

long int hk_column::asinteger ( void )

long int hk_column::asinteger_at ( unsigned long )

hk_string hk_column::asstring ( bool as_locale = true )

returns the value of this column, type converted to a hk_string. (All columntypes except BINARY).
Parameters:

as_locale if true numbers, times and dates will be displayed in the users localized version

hk_string hk_column::asstring_at ( unsigned long a,

bool as_locale = true

)

returns the value at a specific position in the column. The row selector will not be changed, so the visible objects will not be informed. Use asstring in combination with hk_datasource::goto_row instead.

hk_string hk_column::bool_falsevalue ( void )

hk_string hk_column::bool_truevalue ( void )

const struct_raw_data* hk_column::changed_data ( void )

returns the new data set by a function like asstring(hk_string& n);

bool hk_column::changed_data_asbool ( void )

double hk_column::changed_data_asdouble ( void )

long int hk_column::changed_data_asinteger ( void )

hk_string hk_column::changed_data_asstring ( bool as_locale = true )

if new data was inserted with the method asstring and the changes have not yet been stored this method returns the changed data

bool hk_column::changed_data_is_nullvalue ( void )

enum_columntype hk_column::columntype ( void ) const

If you need the column type as a hk_string use columntype_name to translate.
Returns:
the type of the column of type enum_columntype.

hk_string hk_column::columntype_name ( void )

to translate the columntype into a hk_string.

long int hk_column::count ( )

long int hk_column::count ( unsigned int from,

unsigned int to

)

bool hk_column::curval_asbool ( void )

returns the current value as a boolean value. The difference to asbool is, that it will return the changed_data if the current data was changed by setting the data with e.g. set_asbool()

double hk_column::curval_asdouble ( void )

returns the current value as a floating point number . The difference to asdouble is, that it will return the changed_data if the current data was changed by setting the data with e.g. set_asdouble()

long int hk_column::curval_asinteger ( void )

returns the current value as a integer. The difference to asinteger is, that it will return the changed_data if the current data was changed by setting the data with e.g. set_asinteger()

hk_string hk_column::curval_asstring ( void )

returns the current value as a string. The difference to asstring is, that it will return the changed_data if the current data was changed by setting the data with e.g. set_asstring()

virtual void hk_column::data_has_changed ( void ) [protected, virtual]

hk_datasource* hk_column::datasource ( void )

void hk_column::datavisible_add ( hk_dsdatavisible * ) [protected]

void hk_column::datavisible_remove ( hk_dsdatavisible * ) [protected]

virtual bool hk_column::driver_specific_asbinary ( const char * b ) [protected, virtual]

virtual const struct_raw_data* hk_column::driver_specific_asbinary_at ( unsigned long a ) [protected, virtual]

virtual void hk_column::driver_specific_asbool ( bool b ) [protected, virtual]

virtual bool hk_column::driver_specific_asbool_at ( unsigned long a ) [protected, virtual]

virtual bool hk_column::driver_specific_asstring ( const hk_string & d ) [protected, virtual]

virtual hk_string hk_column::driver_specific_asstring_at ( unsigned long a ) [protected, virtual]

virtual bool hk_column::driver_specific_is_nullvalue_at ( unsigned long ) [protected, virtual]

virtual const char* hk_column::driver_specific_transformed_asstring_at ( unsigned long ) [inline, protected, virtual]

unsigned int hk_column::fieldnumber ( void )

A temporarily given unique number of this row

unsigned int hk_column::find ( const hk_string & searchtext,

bool wholephrase = false,

bool casesensitive = false,

bool backwards = false

)

search from the beginning to the end for searchtext
Parameters:

searchtext value as hk_string to look for

Returns:
row number if found, max_rows()+1 if not found

unsigned int hk_column::find ( unsigned int from,

unsigned int to,

const hk_string & searchtext,

bool wholephrase = false,

bool casesensitive = false,

bool backwards = false

)

search for a specific value in a column
Parameters:

from number of the first row where the search has to start. First row is number 0

to number of the last row where the search has to end. Last row is number max_rows-1;

searchtext value as hk_string to look for

wholephrase if false the searchtext is part of columnvalue, if true it has to be an exact match

casesensitive if true a case sensitive compararation is used

backwards searching backwards, default is forward

Returns:
row number if found, max_rows()+1 if not found

hk_string hk_column::get_delimiter ( void )

Returns:
A string value representing the proper delimiter to use.

bool hk_column::has_changed ( void )

Returns:
true if the value of the column has changed and not yet saved in the database.

bool hk_column::in_definitionmode ( void )

data type, name and some other metadata can only be changed if the datasource is either in create_mode or alter_mode (or while the datasource enables and automatically creates columns)
Returns:
true if metadata can be modified, else false

bool hk_column::is_findstring ( unsigned int pos,

const hk_string & searchtext,

bool wholephrase = false,

bool casesensitive = false

)

an internal used function which compares the column value at row number "pos"

bool hk_column::is_notnull ( void )

Returns:
true if this column has to have a value.

bool hk_column::is_nullvalue ( void )

bool hk_column::is_nullvalue_at ( unsigned long a )

bool hk_column::is_primary ( void )

Returns:
true if this column is part of the primary key (primary index).

bool hk_column::is_readonly ( void ) const

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

void hk_column::load_columndefinition ( const hk_string & )

bool hk_column::load_from_file ( const hk_string & filename )

changes the value of the column with the content of the file"filename". Very useful for binary columns.

hk_string hk_column::name ( void ) const

name of the column

void hk_column::reset_changed_data ( void )

set all changed data back to it's default value. Usually you don´t have to call this function

void hk_column::save_columndefinition ( ostream & )

bool hk_column::save_to_file ( const hk_string & filename )

save the value of this column in a file. Very useful for binary-columns

void hk_column::set_allow_autoincwrite ( bool r )

a column of type autoinc is usually readonly. if allow_autoincwrite is set to true it will be writeable if the database driver supports it

void hk_column::set_asbinary ( const struct_raw_data * rd )

changes the value of the column in native form.(i.e. Binary data)
See also:
load_from_file

void hk_column::set_asbool ( bool b )

Parameters:

b new value of the column.

void hk_column::set_asdouble ( double s,

bool registerchange = true

)

Parameters:

s new value of the column.

void hk_column::set_asinteger ( long int s,

bool registerchange = true

)

Parameters:

s new value of the column.

void hk_column::set_asnullvalue ( bool registerchange = true )

void hk_column::set_asstring ( const hk_string & s,

bool registerchange,

bool is_locale

)

void hk_column::set_asstring ( const hk_string & s,

bool registerchange = true

)

Parameters:

s new value of the column.

void hk_column::set_boolvalues ( const hk_string & TRUESTRING,

const hk_string & FALSESTRING

)

you have the possibility to set the values which the column will accept as true and false. i.e. 0 and 1 for numeric columns or for text columns yes and no, or true and false.

void hk_column::set_columntype ( enum_columntype f )

can just be edited if the datasource is in the mode ALTER or CREATE.

void hk_column::set_dateformat ( const hk_string & df ) [inline]

if the column is of type date, time or datetime you can specify the wished format with this function. See hk_datetime for details.

void hk_column::set_datetimeformat ( const hk_string & dtf ) [inline]

if the column is of type date, time or datetime you can specify the wished format with this function. See hk_datetime for details.

void hk_column::set_definitionmode ( bool def )

void hk_column::set_name ( const hk_string & n )

name of the column. Can just be edited if the datasource is in the mode ALTER or CREATE.

bool hk_column::set_notnull ( bool i )

can just be edited if the datasource is in the mode ALTER or CREATE.

bool hk_column::set_primary ( bool i )

can only be edited if the datasource is in the mode ALTER or CREATE.

void hk_column::set_readonly ( bool r )

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

void hk_column::set_size ( long s )

can just be edited if the datasource is in the mode ALTER or CREATE.

void hk_column::set_timeformat ( const hk_string & tf ) [inline]

if the column is of type date, time or datetime you can specify the wished format with this function. See hk_datetime for details.

long hk_column::size ( void )

column length in bytes

double hk_column::sum ( )

double hk_column::sum ( unsigned int from,

unsigned int to

)

hk_string hk_column::tableorigin ( void )

const char* hk_column::transformed_asstring ( void )

Columns can contain characters such as \0, \n, ' and so on. Some SQL Servers need to encode this data, so this function delivers the encoded and nonlocalized version.

const char* hk_column::transformed_asstring_at ( unsigned long position )

const struct_raw_data* hk_column::transformed_changed_data ( void )

returns the new data set by a function like asstring(hk_string& n) in SQL server native form.