--- parser3/src/classes/hash.C	2017/05/17 14:22:11	1.142
+++ parser3/src/classes/hash.C	2021/11/04 21:31:15	1.151
@@ -1,7 +1,7 @@
 /** @file
 	Parser: @b hash parser class.
 
-	Copyright (c) 2001-2017 Art. Lebedev Studio (http://www.artlebedev.com)
+	Copyright (c) 2001-2020 Art. Lebedev Studio (http://www.artlebedev.com)
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
@@ -17,7 +17,7 @@
 #include "pa_vbool.h"
 #include "pa_vmethod_frame.h"
 
-volatile const char * IDENT_HASH_C="$Id: hash.C,v 1.142 2017/05/17 14:22:11 moko Exp $";
+volatile const char * IDENT_HASH_C="$Id: hash.C,v 1.151 2021/11/04 21:31:15 moko Exp $";
 
 // class
 
@@ -37,7 +37,6 @@ DECLARE_CLASS_VAR(hash, new MHash);
 
 #ifndef DOXYGEN
 class Hash_sql_event_handlers: public SQL_Driver_query_event_handlers {
-	const String& statement_string; const char* statement_cstr;
 	bool distinct;
 	HashStringValue& rows_hash;
 	Value* row_value;
@@ -50,15 +49,7 @@ class Hash_sql_event_handlers: public SQ
 public:
 	Table* empty;
 public:
-	Hash_sql_event_handlers(
-		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),
+	Hash_sql_event_handlers(bool adistinct, HashStringValue& arows_hash, Table2hash_value_type avalue_type):
 		distinct(adistinct),
 		rows_hash(arows_hash),
 		row_value(0),
@@ -81,13 +72,13 @@ public:
 
 	bool before_rows(SQL_Error& error) { 
 		if(columns.count()<1) {
-			error=SQL_Error(PARSER_RUNTIME, "no columns");
+			error=SQL_Error("no columns");
 			return true;
 		}
 		switch(value_type){
 			case C_STRING: {
 				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;
 				}
 			}
@@ -110,7 +101,7 @@ public:
 
 	bool add_row_cell(SQL_Error& error, const char *str, size_t ) {
 		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;
 			if(one_bool_column) {
@@ -173,7 +164,7 @@ public:
 			}
 
 			if(duplicate & !distinct) {
-				error=SQL_Error(PARSER_RUNTIME, "duplicate key");
+				error=SQL_Error("duplicate key");
 				return true;
 			}
 
@@ -284,12 +275,6 @@ 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 int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders);
 extern void unmarshal_bind_updates(HashStringValue& hash, int placeholder_count, SQL_Driver::Placeholder* placeholders);
@@ -338,19 +323,10 @@ static void _sql(Request& r, MethodParam
 	const char* statement_cstr=statement_string.untaint_cstr(String::L_SQL, r.connection());
 
 	HashStringValue& hash=GET_SELF(r, VHashBase).hash();
-	hash.clear();	
-	Hash_sql_event_handlers handlers(
-		statement_string, statement_cstr, 
-		distinct,
-		hash,
-		value_type);
-
-	r.connection()->query(
-		statement_cstr, 
-		placeholders_count, placeholders,
-		offset, limit,
-		handlers,
-		statement_string);
+	hash.clear();
+	Hash_sql_event_handlers handlers(distinct, hash, value_type);
+
+	r.connection()->query(statement_cstr, placeholders_count, placeholders, offset, limit, handlers, statement_string);
 
 	if(bind)
 		unmarshal_bind_updates(*bind, placeholders_count, placeholders);
@@ -467,7 +443,7 @@ inline Value& SingleElementHash(String::
 }
 
 #ifndef DOXYGEN
-struct Hash_seq_item {
+struct Hash_seq_item : public PA_Allocated {
 	HashStringValue::Pair *hash_pair;
 	union {
 		const char *c_str;
@@ -505,7 +481,7 @@ static void _sort(Request& r, MethodPara
 	HashStringValue& hash=GET_SELF(r, VHashBase).hash();
 	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;
 	bool key_values_are_strings=true;
 
@@ -643,6 +619,124 @@ static void _at(Request& r, MethodParams
 	}
 }
 
+extern String table_reverse_name;
+
+static void _select(Request& r, MethodParams& params) {
+	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());
+
+				if(r.process(vcondition).as_bool()){
+					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());
+
+				if(r.process(vcondition).as_bool()){
+					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);
+
+		for(HashStringValue::Iterator i(*names); i; i.next())
+			hash.rename(i.key(), i.value()->as_string());
+	}
+}
+
+
 // constructor
 
 MHash::MHash(): Methoded("hash") 
@@ -682,12 +776,22 @@ MHash::MHash(): Methoded("hash")
 
 	// ^hash.sort[key;value]{string-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([-+]offset)[['key'|'value'|'hash']]
 	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
 	// aliases without "_"
 	add_native_method("keys", Method::CT_DYNAMIC, _keys, 0, 1);