parser3/src/classes/hash.C - diff

Return to hash.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/hash.C between versions 1.141 and 1.161

version 1.141, 2017/02/07 22:00:27	version 1.161, 2024/09/27 23:38:52
Line 1	Line 1
/** @file	/** @file
Parser: @b hash parser class.	Parser: @b hash parser class.

Copyright (c) 2001-2017 Art. Lebedev Studio (http://www.artlebedev.com)	Copyright (c) 2001-2023 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <paf@design.ru>
*/	*/

#include "classes.h"	#include "classes.h"
Line 37 DECLARE_CLASS_VAR(hash, new MHash);	Line 37 DECLARE_CLASS_VAR(hash, new MHash);

#ifndef DOXYGEN	#ifndef DOXYGEN
class Hash_sql_event_handlers: public SQL_Driver_query_event_handlers {	class Hash_sql_event_handlers: public SQL_Driver_query_event_handlers {
const String& statement_string; const char* statement_cstr;
bool distinct;	bool distinct;
HashStringValue& rows_hash;	HashStringValue& result;
Value* row_value;	Value* row_value;
int column_index;	int column_index;
ArrayString& columns;	ArrayString& columns;
bool one_bool_column;	bool one_bool_column;
static VBool only_one_column_value;
Table2hash_value_type value_type;	Table2hash_value_type value_type;
int columns_count;	int columns_count;
public:	public:
Table* empty;	Table* empty;
public:	public:
Hash_sql_event_handlers(	Hash_sql_event_handlers(bool adistinct, HashStringValue& aresult, Table2hash_value_type avalue_type):
const String& astatement_string,
const char* astatement_cstr,
bool adistinct,
HashStringValue& arows_hash,
Table2hash_value_type avalue_type)
:
statement_string(astatement_string),
statement_cstr(astatement_cstr),
distinct(adistinct),	distinct(adistinct),
rows_hash(arows_hash),	result(aresult),
row_value(0),	row_value(0),
column_index(0),	column_index(0),
columns(*new ArrayString),	columns(*new ArrayString),
Line 74 public:	Line 64 public:
columns+=new String(str, String::L_TAINTED /* no length as 0x00 can be inside */);	columns+=new String(str, String::L_TAINTED /* no length as 0x00 can be inside */);
return false;	return false;
} catch(...) {	} catch(...) {
error=SQL_Error("exception occured in Hash_sql_event_handlers::add_column");	error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_column");
return true;	return true;
}	}
}	}

bool before_rows(SQL_Error& error) {	bool before_rows(SQL_Error& error) {
if(columns.count()<1) {	if(columns.count()<1) {
error=SQL_Error(PARSER_RUNTIME, "no columns");	error=SQL_Error("no columns");
return true;	return true;
}	}
switch(value_type){	switch(value_type){
case C_STRING: {	case C_STRING: {
if(columns.count()>2){	if(columns.count()>2){
error=SQL_Error(PARSER_RUNTIME, "only 2 columns allowed for $.type[string].");	error=SQL_Error("only 2 columns allowed for $.type[string].");
return true;	return true;
}	}
}	}
Line 110 public:	Line 100 public:

bool add_row_cell(SQL_Error& error, const char *str, size_t ) {	bool add_row_cell(SQL_Error& error, const char *str, size_t ) {
try {	try {
const String& cell=str?new String(str, String::L_TAINTED / no length as 0x00 can be inside */):String::Empty;	const String& cell=str ? new String(str, String::L_TAINTED / no length as 0x00 can be inside */) : String::Empty;

bool duplicate=false;	bool duplicate=false;
if(one_bool_column) {	if(one_bool_column) {
duplicate=rows_hash.put_dont_replace(cell, &only_one_column_value); // put. existed?	duplicate=result.put_dont_replace(cell, &VBool::get(true)); // put. existed?
} else if(column_index==0) {	} else if(column_index==0) {
switch(value_type){	switch(value_type){
case C_HASH: {	case C_HASH: {
VHash* row_vhash=new VHash;	VHash* row_vhash=new VHash;
row_value=row_vhash;	row_value=row_vhash;
duplicate=rows_hash.put_dont_replace(cell, row_vhash); // put. existed?	duplicate=result.put_dont_replace(cell, row_vhash); // put. existed?
break;	break;
}	}
case C_STRING: {	case C_STRING: {
VString* row_vstring=new VString();	VString* row_vstring=new VString();
row_value=row_vstring;	row_value=row_vstring;
duplicate=rows_hash.put_dont_replace(cell, row_vstring); // put. existed?	duplicate=result.put_dont_replace(cell, row_vstring); // put. existed?
break;	break;
}	}
case C_TABLE: {	case C_TABLE: {
VTable* vtable=(VTable*)rows_hash.get(cell);	VTable* vtable=(VTable*)result.get(cell);
Table* table;

if(vtable) { // table with this key exist?	if(vtable) { // table with this key exist?
if(!distinct) {	if(!distinct) {
duplicate=true;	duplicate=true;
break;	break;
}	}
table=vtable->get_table();
} else {	} else {
// no? creating table of same structure as source	// no? creating table of same structure as source
Table::Action_options table_options(0, 0);	Table::Action_options table_options(0, 0);
table=new Table(empty, table_options/no rows, just structure*/);	vtable=new VTable(new Table(empty, table_options/no rows, just structure*/));
vtable=new VTable(table);	result.put(cell, vtable); // put
rows_hash.put(cell, vtable); // put
}	}
ArrayString* row=new ArrayString(columns_count);	ArrayString* row=new ArrayString(columns_count);
row_value=(Value*)row;	row_value=(Value*)row;
*row+=&cell;	*row+=&cell;
*table+=row;	*vtable->get_table()+=row;
break;	break;
}	}
}	}
Line 173 public:	Line 160 public:
}	}

if(duplicate & !distinct) {	if(duplicate & !distinct) {
error=SQL_Error(PARSER_RUNTIME, "duplicate key");	error=SQL_Error("duplicate key");
return true;	return true;
}	}

column_index++;	column_index++;
return false;	return false;
} catch(...) {	} catch(...) {
error=SQL_Error("exception occured in Hash_sql_event_handlers::add_row_cell");	error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_row_cell");
return true;	return true;
}	}
}	}

};	};
VBool Hash_sql_event_handlers::only_one_column_value(true);

#endif	#endif

Line 197 static void _create_or_add(Request& r, M	Line 183 static void _create_or_add(Request& r, M
HashStringValue* self_hash=&(self.hash());	HashStringValue* self_hash=&(self.hash());
HashStringValue* src_hash;	HashStringValue* src_hash;

if(VHashBase* src=static_cast<VHashBase*>(vsrc.as(VHASH_TYPE))) {	if(VHashBase* src=dynamic_cast<VHashBase*>(&vsrc)) {
src_hash=&(src->hash());	src_hash=&(src->hash());

if(src_hash==self_hash) // same: doing nothing	if(src_hash==self_hash) // same: doing nothing
Line 247 struct Copy_intersection_to_info {	Line 233 struct Copy_intersection_to_info {
HashStringValue* dest;	HashStringValue* dest;
};	};
#endif	#endif
static void copy_intersection_to(HashStringValue::key_type key, HashStringValue::value_type value, Copy_intersection_to_info *info) {
	static void copy_intersection_by_arg(HashStringValue::key_type key, HashStringValue::value_type, Copy_intersection_to_info *info) {
	if(HashStringValue::value_type value=info->b->get(key))
	info->dest->put_dont_replace(key, value);
	}

	static void copy_intersection_by_self(HashStringValue::key_type key, HashStringValue::value_type value, Copy_intersection_to_info *info) {
if(info->b->get(key))	if(info->b->get(key))
info->dest->put_dont_replace(key, value);	info->dest->put_dont_replace(key, value);
}	}

static void _intersection(Request& r, MethodParams& params) {	static void _intersection(Request& r, MethodParams& params) {
Value& result=*new VHash;	Value& result=*new VHash;
// dest += b
	bool order_by_arg=false;
	if(params.count()>1)
	if(HashStringValue* options=params.as_hash(1, "options")) {
	int valid_options=0;
	if(Value* vorder=options->get("order")) {
	const String &sorder=r.process(*vorder).as_string();
	if(sorder == "arg")
	order_by_arg=true;
	else if(sorder != "self")
	throw Exception(PARSER_RUNTIME, &sorder, "'order' must be 'self' or 'arg'");
	valid_options++;
	}
	if(valid_options!=options->count())
	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
	}

if(HashStringValue* b=params.as_hash(0, "param")) {	if(HashStringValue* b=params.as_hash(0, "param")) {
Copy_intersection_to_info info={b, result.get_hash()};	if(order_by_arg){
GET_SELF(r, VHashBase).hash().for_each<Copy_intersection_to_info*>(copy_intersection_to, &info);	Copy_intersection_to_info info={&GET_SELF(r, VHashBase).hash(), result.get_hash()};
	b->for_each<Copy_intersection_to_info*>(copy_intersection_by_arg, &info);
	} else {
	Copy_intersection_to_info info={b, result.get_hash()};
	GET_SELF(r, VHashBase).hash().for_each<Copy_intersection_to_info*>(copy_intersection_by_self, &info);
	}
}	}

// return result
r.write(result);	r.write(result);
}	}

Line 284 static void _intersects(Request& r, Meth	Line 297 static void _intersects(Request& r, Meth
}	}


extern String sql_bind_name;
extern String sql_limit_name;
extern String sql_offset_name;
extern String sql_default_name;
extern String sql_distinct_name;
extern String sql_value_type_name;
extern Table2hash_value_type get_value_type(Value& vvalue_type);	extern Table2hash_value_type get_value_type(Value& vvalue_type);
extern int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders);	extern int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders);
extern void unmarshal_bind_updates(HashStringValue& hash, int placeholder_count, SQL_Driver::Placeholder* placeholders);	extern void unmarshal_bind_updates(HashStringValue& hash, int placeholder_count, SQL_Driver::Placeholder* placeholders);
Line 305 static void _sql(Request& r, MethodParam	Line 312 static void _sql(Request& r, MethodParam
if(params.count()>1)	if(params.count()>1)
if(HashStringValue* options=params.as_hash(1, "sql options")) {	if(HashStringValue* options=params.as_hash(1, "sql options")) {
int valid_options=0;	int valid_options=0;
if(Value* vbind=options->get(sql_bind_name)) {	for(HashStringValue::Iterator i(*options); i; i.next() ){
valid_options++;	String::Body key=i.key();
bind=vbind->get_hash();	Value* value=i.value();
}	if(key == sql_bind_name) {
if(Value* vlimit=options->get(sql_limit_name)) {	bind=value->get_hash();
valid_options++;	valid_options++;
limit=(ulong)r.process(*vlimit).as_double();	} else if(key == sql_limit_name) {
}	limit=(ulong)r.process(*value).as_double();
if(Value* voffset=options->get(sql_offset_name)) {	valid_options++;
valid_options++;	} else if(key == sql_offset_name) {
offset=(ulong)r.process(*voffset).as_double();	offset=(ulong)r.process(*value).as_double();
}	valid_options++;
if(Value* vdistinct=options->get(sql_distinct_name)) {	} else if (key == sql_distinct_name) {
valid_options++;	distinct=r.process(*value).as_bool();
distinct=r.process(*vdistinct).as_bool();	valid_options++;
}	} else if (key == sql_value_type_name) {
if(Value* vvalue_type=options->get(sql_value_type_name)) {	value_type=get_value_type(r.process(*value));
valid_options++;	valid_options++;
value_type=get_value_type(r.process(*vvalue_type));	}
}	}
if(valid_options!=options->count())	if(valid_options!=options->count())
throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
Line 338 static void _sql(Request& r, MethodParam	Line 345 static void _sql(Request& r, MethodParam
const char* statement_cstr=statement_string.untaint_cstr(String::L_SQL, r.connection());	const char* statement_cstr=statement_string.untaint_cstr(String::L_SQL, r.connection());

HashStringValue& hash=GET_SELF(r, VHashBase).hash();	HashStringValue& hash=GET_SELF(r, VHashBase).hash();
hash.clear();	hash.clear();
Hash_sql_event_handlers handlers(	Hash_sql_event_handlers handlers(distinct, hash, value_type);
statement_string, statement_cstr,
distinct,	r.connection()->query(statement_cstr, placeholders_count, placeholders, offset, limit, handlers, statement_string);
hash,
value_type);

r.connection()->query(
statement_cstr,
placeholders_count, placeholders,
offset, limit,
handlers,
statement_string);

if(bind)	if(bind)
unmarshal_bind_updates(*bind, placeholders_count, placeholders);	unmarshal_bind_updates(*bind, placeholders_count, placeholders);
Line 467 inline Value& SingleElementHash(String::	Line 465 inline Value& SingleElementHash(String::
}	}

#ifndef DOXYGEN	#ifndef DOXYGEN
struct Hash_seq_item {	struct Hash_seq_item : public PA_Allocated {
HashStringValue::Pair *hash_pair;	HashStringValue::Pair *hash_pair;
union {	union {
const char *c_str;	const char *c_str;
Line 505 static void _sort(Request& r, MethodPara	Line 503 static void _sort(Request& r, MethodPara
HashStringValue& hash=GET_SELF(r, VHashBase).hash();	HashStringValue& hash=GET_SELF(r, VHashBase).hash();
int count=hash.count();	int count=hash.count();

Hash_seq_item* seq=new(PointerFreeGC) Hash_seq_item[count];	Hash_seq_item* seq=new Hash_seq_item[count];
int pos=0;	int pos=0;
bool key_values_are_strings=true;	bool key_values_are_strings=true;

Line 643 static void _at(Request& r, MethodParams	Line 641 static void _at(Request& r, MethodParams
}	}
}	}

	extern String table_reverse_name;

	static void _select(Request& r, MethodParams& params) {
	InCycle temp(r);
	const String* key_var_name=&params.as_string(0, "key-var name must be string");
	const String* value_var_name=&params.as_string(1, "value-var name must be string");
	Value& vcondition=params.as_expression(2, "condition must be number, bool or expression");

	if(key_var_name->is_empty()) key_var_name=0;
	if(value_var_name->is_empty()) value_var_name=0;

	HashStringValue& source_hash=GET_SELF(r, VHashBase).hash();
	Value& caller=*r.get_method_frame()->caller();

	int limit=source_hash.count();
	bool reverse=false;
	bool copy_default=false;

	if(params.count()>3)
	if(HashStringValue* options=params.as_hash(3)) {
	int valid_options=0;
	if(Value* vlimit=options->get(sql_limit_name)) {
	valid_options++;
	limit=r.process(*vlimit).as_int();
	}
	if(Value* vreverse=options->get(table_reverse_name)) {
	valid_options++;
	reverse=r.process(*vreverse).as_bool();
	}
	if(Value* vcopy_default=options->get(sql_default_name)) {
	valid_options++;
	copy_default=r.process(*vcopy_default).as_bool();
	}
	if(valid_options!=options->count())
	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
	}

	HashStringValue& result_hash=*new HashStringValue();

	if(limit>0){

	#ifdef HASH_ORDER
	if(reverse){
	for(HashStringValue::ReverseIterator i(source_hash); i; i.prev()){
	if(key_var_name)
	r.put_element(caller, key_var_name, new VString(new String(i.key(), String::L_TAINTED)));
	if(value_var_name)
	r.put_element(caller, *value_var_name, i.value());

	bool condition=r.process(vcondition).as_bool();

	if(r.check_skip_break())
	break;

	if(condition){
	result_hash.put(i.key(), i.value());
	if(!--limit)
	break;
	}
	}
	} else {
	#else
	{
	#endif
	for(HashStringValue::Iterator i(source_hash); i; i.next() ){
	if(key_var_name)
	r.put_element(caller, key_var_name, new VString(new String(i.key(), String::L_TAINTED)));
	if(value_var_name)
	r.put_element(caller, *value_var_name, i.value());

	bool condition=r.process(vcondition).as_bool();

	if(r.check_skip_break())
	break;

	if(condition){
	result_hash.put(i.key(), i.value());
	if(!--limit)
	break;
	}
	}
	}
	}

	VHash *result=new VHash(result_hash);
	if(copy_default){
	result->set_default(GET_SELF(r, VHashBase).get_default());
	}

	r.write(*result);
	}

	static void _reverse(Request& r, MethodParams& params) {
	VHashBase& self=GET_SELF(r, VHashBase);
	HashStringValue& source_hash=self.hash();
	HashStringValue& result_hash=*new HashStringValue();

	#ifdef HASH_ORDER
	for(HashStringValue::ReverseIterator i(source_hash); i; i.prev())
	result_hash.put(i.key(), i.value());
	#else
	for(HashStringValue::Iterator i(source_hash); i; i.next() )
	result_hash.put(i.key(), i.value());
	#endif

	VHashBase& result=*new VHash(result_hash);
	if(Value* vdefault=self.get_default())
	result.set_default(vdefault);

	r.write(result);
	}


	static void _rename(Request& r, MethodParams& params) {
	HashStringValue& hash=GET_SELF(r, VHashBase).hash();

	if(params.count()>1){
	const String& key_from=params.as_string(0, "from key must be string");
	const String& key_to=params.as_string(1, "to key must be string");

	hash.rename(key_from, key_to);
	} else {
	HashStringValue* names=params.as_hash(0,"single parameter");

	for(HashStringValue::Iterator i(*names); i; i.next())
	hash.rename(i.key(), i.value()->as_string());
	}
	}


// constructor	// constructor

MHash::MHash(): Methoded("hash")	MHash::MHash(): Methoded("hash")
Line 655 MHash::MHash(): Methoded("hash")	Line 783 MHash::MHash(): Methoded("hash")
add_native_method("sub", Method::CT_DYNAMIC, _sub, 1, 1);	add_native_method("sub", Method::CT_DYNAMIC, _sub, 1, 1);
// ^a.union[b] = hash	// ^a.union[b] = hash
add_native_method("union", Method::CT_DYNAMIC, _union, 1, 1);	add_native_method("union", Method::CT_DYNAMIC, _union, 1, 1);
// ^a.intersection[b] = hash	// ^a.intersection[b][options hash] = hash
add_native_method("intersection", Method::CT_DYNAMIC, _intersection, 1, 1);	add_native_method("intersection", Method::CT_DYNAMIC, _intersection, 1, 2);
// ^a.intersects[b] = bool	// ^a.intersects[b] = bool
add_native_method("intersects", Method::CT_DYNAMIC, _intersects, 1, 1);	add_native_method("intersects", Method::CT_DYNAMIC, _intersects, 1, 1);

Line 682 MHash::MHash(): Methoded("hash")	Line 810 MHash::MHash(): Methoded("hash")

// ^hash.sort[key;value]{string-key-maker}[[asc\|desc]]	// ^hash.sort[key;value]{string-key-maker}[[asc\|desc]]
// ^hash.sort[key;value](numeric-key-maker)[[asc\|desc]]	// ^hash.sort[key;value](numeric-key-maker)[[asc\|desc]]
add_native_method("sort", Method::CT_DYNAMIC, _sort, 2+1, 2+1+1);	add_native_method("sort", Method::CT_DYNAMIC, _sort, 3, 4);

	// ^hash.select[key;value](bool-condition)[options hash]
	add_native_method("select", Method::CT_DYNAMIC, _select, 3, 4);

	// ^hash.reverse[]
	add_native_method("reverse", Method::CT_DYNAMIC, _reverse, 0, 0);

// ^hash._at[first\|last[;'key'\|'value'\|'hash']]	// ^hash._at[first\|last[;'key'\|'value'\|'hash']]
// ^hash._at([-+]offset)[['key'\|'value'\|'hash']]	// ^hash._at([-+]offset)[['key'\|'value'\|'hash']]
add_native_method("_at", Method::CT_DYNAMIC, _at, 1, 2);	add_native_method("_at", Method::CT_DYNAMIC, _at, 1, 2);

	// ^hash.rename[from;to]
	// ^hash.rename[ $.from[to] ... ]
	add_native_method("rename", Method::CT_DYNAMIC, _rename, 1, 2);

#ifdef FEATURE_GET_ELEMENT4CALL	#ifdef FEATURE_GET_ELEMENT4CALL
// aliases without "_"	// aliases without "_"
add_native_method("keys", Method::CT_DYNAMIC, _keys, 0, 1);	add_native_method("keys", Method::CT_DYNAMIC, _keys, 0, 1);

E-mail:

Removed from v.1.141
changed lines
	Added in v.1.161