--- parser3/src/classes/array.C	2024/09/16 23:22:52	1.4
+++ parser3/src/classes/array.C	2024/10/26 18:53:36	1.26
@@ -17,7 +17,7 @@
 #include "pa_vbool.h"
 #include "pa_vmethod_frame.h"
 
-volatile const char * IDENT_ARRAY_C="$Id: array.C,v 1.4 2024/09/16 23:22:52 moko Exp $";
+volatile const char * IDENT_ARRAY_C="$Id: array.C,v 1.26 2024/10/26 18:53:36 moko Exp $";
 
 // class
 
@@ -33,37 +33,544 @@ public:
 
 DECLARE_CLASS_VAR(array, new MArray);
 
+const char* const PARAM_ARRAY_OR_HASH = "param must be array or hash";
+const char* const PARAM_INDEX = "index must be integer";
+
 // methods
 
-static void _create_or_add(Request& r, MethodParams& params) {
+static void _copy_or_add(Request& r, MethodParams& params) {
 	if(params.count()) {
-		Value& vsrc=params.as_no_junction(0, PARAM_MUST_BE_HASH);
+		Value& vsrc=params.as_no_junction(0, PARAM_ARRAY_OR_HASH);
 		VArray& self=GET_SELF(r, VArray);
 		ArrayValue& self_array=self.array();
 
 		if(VArray* src=dynamic_cast<VArray*>(&vsrc)) {
-			ArrayValue& src_array =src->array();
-			if(&src_array==&self_array) // same: doing nothing
+			if(src==&self)
+				return;
+			if(self_array.count()){
+				for(ArrayValue::Iterator i(src->array()); i; i.next()){
+					if(i.value())
+						self_array.put(i.index(), i.value());
+				}
+			} else {
+				self_array.append(src->array());
+			}
+		} else {
+			HashStringValue* src_hash=vsrc.as_hash("param must be array or");
+			if(!src_hash)
 				return;
+			for(HashStringValue::Iterator i(*src_hash); i; i.next()){
+				self_array.put(VArray::index(i.key()), i.value());
+			}
+		}
+		self_array.invalidate();
+	}
+}
+
+static ArrayValue::Action_options get_action_options(Request& r, MethodParams& params, size_t options_index) {
+	ArrayValue::Action_options result;
+	if(params.count() <= options_index)
+		return result;
+
+	HashStringValue* options=params.as_hash(options_index);
+	if(!options)
+		return result;
+
+	result.defined=true;
+	int valid_options=0;
+
+	if(Value* voffset=options->get(sql_offset_name)) {
+		valid_options++;
+		int offset=r.process(*voffset).as_int();
+		result.offset=offset < 0 ? 0 : offset;
+	}
+	if(Value* vlimit=options->get(sql_limit_name)) {
+		valid_options++;
+		int limit=r.process(*vlimit).as_int();
+		result.limit=limit < 0 ? 0: limit;
+	}
+
+	if(valid_options!=options->count())
+		throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
+
+	return result;
+}
+
+static void _join(Request& r, MethodParams& params) {
+	Value& vsrc=params.as_no_junction(0, PARAM_ARRAY_OR_HASH);
+	ArrayValue::Action_options o=get_action_options(r, params, 1);
+
+	VArray& self=GET_SELF(r, VArray);
+	ArrayValue& self_array=self.array();
+
+	if(VArray* src=dynamic_cast<VArray*>(&vsrc)) {
+		if(src==&self)
+			throw Exception(PARSER_RUNTIME, 0, "source and destination are the same array");
+
+		if(o.defined){
+			for(ArrayValue::Iterator i(src->array()); i; i.next()){
+				if(i.value()){
+					if(o.offset > 0){
+						o.offset--;
+						continue;
+					}
+					if(o.limit-- == 0)
+						break;
+					self_array+=i.value();
+				}
+			}
 		} else {
-			HashStringValue* src_hash=vsrc.get_hash();
-			if(src_hash)
-				for(HashStringValue::Iterator i(*src_hash); i; i.next())
+			for(ArrayValue::Iterator i(src->array()); i; i.next()){
+				if(i.value())
 					self_array+=i.value();
+			}
+		}
+	} else {
+		HashStringValue* src_hash=vsrc.as_hash("param must be array or");
+		if(!src_hash)
+			return;
+		if(o.defined){
+			for(HashStringValue::Iterator i(*src_hash); i; i.next()){
+				if(o.offset > 0){
+					o.offset--;
+					continue;
+				}
+				if(o.limit-- == 0)
+					break;
+				self_array+=i.value();
+			}
+		} else {
+			for(HashStringValue::Iterator i(*src_hash); i; i.next()){
+				self_array+=i.value();
+			}
+		}
+	}
+	self_array.invalidate();
+}
+
+#ifndef DOXYGEN
+
+#define STRING(str) ((str) ? *new String(str, String::L_TAINTED /* no length as 0x00 can be inside */) : String::Empty)
+
+class SparseArray_sql_event_handlers: public SQL_Driver_query_event_handlers {
+	bool distinct;
+	ArrayValue& result;
+	Value* row_value;
+	int column_index;
+	ArrayString* columns;
+	bool one_bool_column;
+	Table2hash_value_type value_type;
+	int columns_count;
+public:
+	Table* empty;
+public:
+	SparseArray_sql_event_handlers(bool adistinct, ArrayValue& aresult, Table2hash_value_type avalue_type):
+		distinct(adistinct),
+		result(aresult),
+		row_value(0),
+		column_index(0),
+		columns(new ArrayString),
+		one_bool_column(false),
+		value_type(avalue_type),
+		empty(0) {
+	}
+
+	bool add_column(SQL_Error& error, const char* str, size_t ) {
+		try {
+			if(columns_count){
+				// another query in multi_statements mode
+				columns=new ArrayString;
+				columns_count=0;
+			}
+			*columns+=&STRING(str);
+			return false;
+		} catch(...) {
+			error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_column");
+			return true;
+		}
+	}
+
+	bool before_rows(SQL_Error& error) {
+		columns_count=columns->count();
+		if(columns_count<1) {
+			error=SQL_Error("no columns");
+			return true;
+		}
+		if(columns_count==1) {
+			one_bool_column=true;
+		} else {
+			switch(value_type){
+				case C_STRING: {
+					if(columns_count>2){
+						error=SQL_Error("only 2 columns allowed for $.type[string] and $.sparse(true)");
+						return true;
+					}
+					break;
+				}
+				case C_TABLE: {
+					// create empty table which we'll copy later
+					empty=new Table(columns);
+					break;
+				}
+			}
+		}
+		return false;
+	}
+
+	bool add_row(SQL_Error& /*error*/) {
+		column_index=0;
+		return false;
+	}
+
+	bool add_row_cell(SQL_Error& error, const char *str, size_t ) {
+		try {
+			if(column_index==columns_count){
+				// should never happen, buggy driver case
+				error=SQL_Error("columns index exceed the columns count");
+				return true;
+			}
+
+			bool duplicate=false;
+			if(one_bool_column) {
+				size_t index=str ? pa_atoui(str) : 0;
+				duplicate=result.put_dont_replace(index, &VBool::get(true));  // put. existed?
+			} else if(column_index==0) {
+				size_t index=str ? pa_atoui(str) : 0;
+				switch(value_type){
+					case C_HASH: {
+						VHash* row_vhash=new VHash;
+						row_value=row_vhash;
+						duplicate=result.put_dont_replace(index, row_vhash); // put. existed?
+						break;
+					}
+					case C_STRING: {
+						VString* row_vstring=new VString();
+						row_value=row_vstring;
+						duplicate=result.put_dont_replace(index, row_vstring);  // put. existed?
+						break;
+					}
+					case C_TABLE: {
+						VTable* vtable=(VTable*)result.get(index);
+
+						if(vtable) { // table with this key exist?
+							if(!distinct) {
+								duplicate=true;
+								break;
+							}
+						} else {
+			 				// no? creating table of same structure as source
+							Table::Action_options table_options(0, 0);
+							vtable=new VTable(new Table(*empty, table_options/*no rows, just structure*/));
+							result.put(index, vtable); // put
+						}
+						ArrayString* row=new ArrayString(columns_count);
+						*row+=&STRING(str);
+						*vtable->get_table()+=row;
+						row_value=(Value*)row;
+						break;
+					}
+				}
+			} else {
+				const String& cell=STRING(str);
+ 				switch(value_type) {
+					case C_HASH: {
+						row_value->get_hash()->put(*columns->get(column_index), new VString(cell));
+						break;
+					}
+					case C_STRING: {
+						VString* row_string=(VString*)row_value;
+						row_string->set_string(cell);
+						break;
+					}
+					case C_TABLE: {
+						ArrayString* row=(ArrayString*)row_value;
+						*row+=&cell;
+						break;
+					}
+				}
+			}
+
+			if(duplicate & !distinct) {
+				error=SQL_Error("duplicate key");
+				return true;
+			}
+
+			column_index++;
+			return false;
+		} catch(const Exception& e) {
+			error=SQL_Error(e.type(), e.comment());
+			return true;
+		} catch(...) {
+			error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_row_cell");
+			return true;
+		}
+	}
+};
+
+class Array_sql_event_handlers: public SQL_Driver_query_event_handlers {
+	ArrayValue& result;
+	Value* row_value;
+	int column_index;
+	ArrayString* columns;
+	Table2hash_value_type value_type;
+	int columns_count;
+public:
+	Table* empty;
+public:
+	Array_sql_event_handlers(ArrayValue& aresult, Table2hash_value_type avalue_type):
+		result(aresult),
+		row_value(0),
+		column_index(0),
+		columns(new ArrayString),
+		value_type(avalue_type),
+		empty(0) {
+	}
+
+	bool add_column(SQL_Error& error, const char* str, size_t ) {
+		try {
+			if(columns_count){
+				// another query in multi_statements mode
+				columns=new ArrayString;
+				columns_count=0;
+			}
+			*columns+=&STRING(str);
+			return false;
+		} catch(...) {
+			error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_column");
+			return true;
+		}
+	}
+
+	bool before_rows(SQL_Error& error) {
+		columns_count=columns->count();
+		if(columns_count<1) {
+			error=SQL_Error("no columns");
+			return true;
+		}
+		switch(value_type){
+			case C_STRING: {
+				if(columns_count>1){
+					error=SQL_Error("only one column allowed for $.type[string]");
+					return true;
+				}
+				break;
+			}
+			case C_TABLE: {
+				// create empty table which we'll copy later
+				empty=new Table(columns);
+				break;
+			}
+		}
+		return false;
+	}
+
+	bool add_row(SQL_Error& /*error*/) {
+		column_index=0;
+		return false;
+	}
+
+	bool add_row_cell(SQL_Error& error, const char *str, size_t ) {
+		try {
+			if(column_index==columns_count){
+				// should never happen, buggy driver case
+				error=SQL_Error("columns index exceed the columns count");
+				return true;
+			}
+
+			if(column_index==0) {
+				switch(value_type){
+					case C_HASH: {
+						VHash* row_vhash=new VHash;
+						row_value=row_vhash;
+						result+=row_vhash;
+						break;
+					}
+					case C_STRING: {
+						VString* row_vstring=new VString();
+						row_value=row_vstring;
+						result+=row_vstring;
+						break;
+					}
+					case C_TABLE: {
+		 				// creating table of same structure as source
+						Table::Action_options table_options(0, 0);
+						VTable* vtable=new VTable(new Table(*empty, table_options/*no rows, just structure*/));
+						ArrayString* row=new ArrayString(columns_count);
+						*vtable->get_table()+=row;
+						row_value=(Value*)row;
+						result+=vtable;
+						break;
+					}
+				}
+			}
+
+			const String& cell=STRING(str);
+			switch(value_type) {
+				case C_HASH: {
+					row_value->get_hash()->put(*columns->get(column_index), new VString(cell));
+					break;
+				}
+				case C_STRING: {
+					VString* row_string=(VString*)row_value;
+					row_string->set_string(cell);
+					break;
+				}
+				case C_TABLE: {
+					ArrayString* row=(ArrayString*)row_value;
+					*row+=&cell;
+					break;
+				}
+			}
+
+			column_index++;
+			return false;
+		} catch(const Exception& e) {
+			error=SQL_Error(e.type(), e.comment());
+			return true;
+		} catch(...) {
+			error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_row_cell");
+			return true;
+		}
+	}
+};
+
+#endif
+
+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);
+
+static void _sql(Request& r, MethodParams& params) {
+	Value& statement=params.as_junction(0, "statement must be code");
+
+	HashStringValue* bind=0;
+	ulong limit=SQL_NO_LIMIT;
+	ulong offset=0;
+	bool distinct=false;
+	bool sparse=false;
+	Table2hash_value_type value_type=C_HASH;
+	if(params.count()>1)
+		if(HashStringValue* options=params.as_hash(1, "sql options")) {
+			int valid_options=0;
+			bool distinct_specified=false;
+			for(HashStringValue::Iterator i(*options); i; i.next() ){
+				String::Body key=i.key();
+				Value* value=i.value();
+				if(key == sql_bind_name) {
+					bind=value->get_hash();
+					valid_options++;
+				} else if(key == sql_limit_name) {
+					limit=(ulong)r.process(*value).as_double();
+					valid_options++;
+				} else if(key == sql_offset_name) {
+					offset=(ulong)r.process(*value).as_double();
+					valid_options++;
+				} else if (key == sql_distinct_name) {
+					distinct=r.process(*value).as_bool();
+					distinct_specified=true;
+					valid_options++;
+				} else if (key == sql_value_type_name) {
+					value_type=get_value_type(r.process(*value));
+					valid_options++;
+				} else if (key == "sparse") {
+					sparse=r.process(*value).as_bool();
+					valid_options++;
+				}
+			}
+			if(valid_options!=options->count())
+				throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
+			if(distinct_specified && !sparse)
+				throw Exception(PARSER_RUNTIME, 0, "'distinct' option can only be used when $.sparse(true) is specified");
+		}
+
+	SQL_Driver::Placeholder* placeholders=0;
+	uint placeholders_count=0;
+	if(bind)
+		placeholders_count=marshal_binds(*bind, placeholders);
+
+	const String& statement_string=r.process_to_string(statement);
+	const char* statement_cstr=statement_string.untaint_cstr(String::L_SQL, r.connection());
+
+	VArray& self=GET_SELF(r, VArray);
+	ArrayValue& array=self.array();
+
+	if(array.count()){
+		array.clear(); array.invalidate(); // just in case if called as method
+	}
+
+	if(sparse){
+		SparseArray_sql_event_handlers handlers(distinct, array, value_type);
+		r.connection()->query(statement_cstr, placeholders_count, placeholders, offset, limit, handlers, statement_string);
+	} else {
+		Array_sql_event_handlers handlers(array, value_type);
+		r.connection()->query(statement_cstr, placeholders_count, placeholders, offset, limit, handlers, statement_string);
+	}
+
+	array.confirm_all_used();
+
+	if(bind)
+		unmarshal_bind_updates(*bind, placeholders_count, placeholders);
+}
+
+
+static void mid(Request& r, size_t offset=0, size_t limit=ARRAY_OPTION_LIMIT_ALL) {
+	ArrayValue& array=GET_SELF(r, VArray).array();
+	if(limit>0){
+		VArray *result=new VArray;
+		ArrayValue& result_array=result->array();
+		for(ArrayValue::Iterator i(array); i; i.next()){
+			if(i.value()){
+				if(offset > 0){
+					offset--;
+					continue;
+				}
+				if(limit-- == 0)
+					break;
+				result_array+=i.value();
+			}
 		}
-		self.invalidate();
+		result_array.confirm_all_used();
+		r.write(*result);
+	} else {
+		r.write(*new VArray);
 	}
 }
 
-static void _sql(Request& r, MethodParams& params) {}
+static void _left(Request& r, MethodParams& params) {
+	int sn=params.as_int(0, "n must be int", r);
+	mid(r, 0, sn < 0 ? 0 : sn);
+}
+
+static void _right(Request& r, MethodParams& params) {
+	int sn=params.as_int(0, "n must be int", r);
 
-static void _sub(Request& r, MethodParams& params) {}
+	if(sn>0){
+		size_t used=GET_SELF(r, VArray).array().used();
+		if((size_t)sn<used){
+			mid(r, used-sn, sn);
+		} else {
+			mid(r);
+		}
+	} else {
+		mid(r, 0, 0);
+	}
+}
 
-static void _union(Request& r, MethodParams& params) {}
+static void _mid(Request& r, MethodParams& params) {
+	int begin=params.as_int(0, "p must be int", r);
 
-static void _intersection(Request& r, MethodParams& params) {}
+	if(begin<0)
+		throw Exception(PARSER_RUNTIME, 0,  "p(%d) must be >=0", begin);
 
-static void _intersects(Request& r, MethodParams& params) {}
+	if(params.count()>1) {
+		int n=params.as_int(1, "n must be int", r);
+		if(n<0)
+			throw Exception(PARSER_RUNTIME, 0, "n(%d) must be >=0", n);
+		mid(r, begin, n);
+	} else {
+		mid(r, begin);
+	}
+}
 
 static void _keys(Request& r, MethodParams& params) {
 	const String* keys_column_name;
@@ -88,55 +595,134 @@ static void _keys(Request& r, MethodPara
 	r.write(*new VTable(table));
 }
 
-static void _count(Request& r, MethodParams&) {
-	r.write(*new VInt(GET_SELF(r, VArray).array().used()));
+static void _count(Request& r, MethodParams& params) {
+	ArrayValue& array=GET_SELF(r, VArray).array();
+	if(params.count()>0){
+		const String& what=params.as_string(0, PARAMETER_MUST_BE_STRING);
+		if(!what.is_empty()){
+			if(what != "all")
+				throw Exception(PARSER_RUNTIME, &what, "param must be empty or 'all'");
+			return r.write(*new VInt(array.count()));
+		}
+	}
+	r.write(*new VInt(array.used()));
 }
 
-static void _append(Request& r, MethodParams& params) {
-	VArray& self=GET_SELF(r, VArray);
-	ArrayValue& array=self.array();
+static void _create_or_append(Request& r, MethodParams& params) {
+	ArrayValue& array=GET_SELF(r, VArray).array();
 
 	int count=params.count();
 
-	for(int i=0; i<count; i++){
-		array+=&r.process(params[i]);
+	if(array.count()){
+		for(int i=0; i<count; i++)
+			array+=&r.process(params[i]);
+		array.invalidate();
+	} else {
+		for(int i=0; i<count; i++)
+			array+=&r.process(params[i]);
+		array.confirm_all_used();
 	}
-	self.invalidate();
 }
 
 static void _insert(Request& r, MethodParams& params) {
-	VArray& self=GET_SELF(r, VArray);
-	ArrayValue& array=self.array();
+	ArrayValue& array=GET_SELF(r, VArray).array();
 
 	int count=params.count();
-	size_t index=VArray::index(params.as_int(0, "index must be integer", r));
+	size_t index=VArray::index(params.as_int(0, PARAM_INDEX, r));
 
 	for(int i=1; i<count; i++){
-		array.insert(index+i-1, &r.process(params[i]));
+		array.insert(index++, &r.process(params[i]));
 	}
-	self.invalidate();
+	array.invalidate();
 }
 
 static void _delete(Request& r, MethodParams& params) {
+	ArrayValue& array=GET_SELF(r, VArray).array();
 	if(params.count()>0)
-		GET_SELF(r, VArray).clear(VArray::index(params.as_int(0, "index must be integer", r)));
+		array.clear(VArray::index(params.as_int(0, PARAM_INDEX, r)));
 	else
-		GET_SELF(r, VArray).clear();
+		array.clear();
+	array.invalidate();
+}
+
+static void _remove(Request& r, MethodParams& params) {
+	ArrayValue& array=GET_SELF(r, VArray).array();
+	array.remove(VArray::index(params.as_int(0, PARAM_INDEX, r)));
+	array.invalidate();
 }
 
 static void _contains(Request& r, MethodParams& params) {
 	VArray& self=GET_SELF(r, VArray);
-	bool result=self.contains(VArray::index(params.as_int(0, "index must be integer", r)));
+	bool result=self.contains(VArray::index(params.as_int(0, PARAM_INDEX, r)));
 	r.write(VBool::get(result));
 }
 
+static void _for(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* body_code=&params.as_junction(2, "body must be code");
+	Value* delim_maybe_code=params.count()>3 ? &params[3] : 0;
+	Value& caller=*r.get_method_frame()->caller();
+
+	if(key_var_name->is_empty()) key_var_name=0;
+	if(value_var_name->is_empty()) value_var_name=0;
+
+	ArrayValue& array=GET_SELF(r, VArray).array();
+
+	if(delim_maybe_code){ // delimiter set
+		bool need_delim=false;
+		for(ArrayValue::Iterator i(array); i; i.next()){
+			if(key_var_name){
+				VString* vkey=new VString(*new String(i.key(), String::L_TAINTED));
+				r.put_element(caller, *key_var_name, vkey);
+			}
+
+			if(value_var_name)
+				r.put_element(caller, *value_var_name, i.value() ? i.value() : VVoid::get());
+
+			Value& sv_processed=r.process(*body_code);
+			TempSkip4Delimiter skip(r);
+
+			const String* s_processed=sv_processed.get_string();
+			if(s_processed && !s_processed->is_empty()) { // we have body
+				if(need_delim) // need delim & iteration produced string?
+					r.write(r.process(*delim_maybe_code));
+				else
+					need_delim=true;
+			}
+
+			r.write(sv_processed);
+
+			if(skip.check_break())
+				break;
+		}
+	} else {
+		for(ArrayValue::Iterator i(array); i; i.next()){
+			if(key_var_name){
+				VString* vkey=new VString(*new String(i.key(), String::L_TAINTED));
+				r.put_element(caller, *key_var_name, vkey);
+			}
+
+			if(value_var_name)
+				r.put_element(caller, *value_var_name, i.value() ? i.value() : VVoid::get());
+
+			r.process_write(*body_code);
+
+			if(r.check_skip_break())
+				break;
+		}
+	}
+}
+
 static void _foreach(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* body_code=&params.as_junction(2, "body must be code");
-	Value* delim_maybe_code=params.count()>3?&params[3]:0;
+	Value* delim_maybe_code=params.count()>3 ? &params[3] : 0;
 	Value& caller=*r.get_method_frame()->caller();
 
 	if(key_var_name->is_empty()) key_var_name=0;
@@ -193,19 +779,6 @@ static void _foreach(Request& r, MethodP
 	}
 }
 
-
-enum AtResultType {
-	AtResultTypeValue = 0,
-	AtResultTypeKey = 1,
-	AtResultTypeHash = 2
-};
-
-inline Value& SingleElementHash(String::Body akey, Value* avalue) {
-	Value& result=*new VHash;
-	result.put_element(*new String(akey, String::L_TAINTED), avalue);
-	return result;
-}
-
 #ifndef DOXYGEN
 struct Array_seq_item : public PA_Allocated {
 	Value *array_data;
@@ -288,13 +861,25 @@ static void _sort(Request& r, MethodPara
 		for(pos=0; pos<count; pos++)
 			array+=seq[pos].array_data;
 
+	array.confirm_all_used();
 	delete[] seq;
 }
 
+enum AtResultType {
+	AtResultTypeValue = 0,
+	AtResultTypeKey = 1,
+	AtResultTypeHash = 2
+};
+
+static Value& SingleElementHash(String::Body akey, Value* avalue) {
+	Value& result=*new VHash;
+	result.put_element(*new String(akey, String::L_TAINTED), avalue);
+	return result;
+}
+
 static void _at(Request& r, MethodParams& params) {
-	VArray& self=GET_SELF(r, VArray);
-	ArrayValue& array=self.array();
-	size_t count=array.count();
+	ArrayValue& array=GET_SELF(r, VArray).array();
+	size_t count=array.used(); // not array.count()
 
 	int pos=0;
 
@@ -323,35 +908,35 @@ static void _at(Request& r, MethodParams
 	}
 
 	if(count && pos >= 0 && (size_t)pos < count){
-		switch(result_type) {
-			case AtResultTypeKey:
-				{
-					for(ArrayValue::Iterator i(array); i; i.next() ){
-						if(i.value() && !(pos--)){
+		if(count == array.count()){
+			switch(result_type) {
+				case AtResultTypeKey:
+					r.write(*new VString(*new String(pa_uitoa(pos), String::L_TAINTED)));
+					break;
+				case AtResultTypeValue:
+					r.write(*array.get(pos));
+					break;
+				case AtResultTypeHash:
+					r.write(SingleElementHash(pa_uitoa(pos), array.get(pos)));
+					break;
+			}
+		} else {
+			for(ArrayValue::Iterator i(array); i; i.next() ){
+				if(i.value() && !(pos--)){
+					switch(result_type) {
+						case AtResultTypeKey:
 							r.write(*new VString(*new String(i.key(), String::L_TAINTED)));
 							break;
-						}
-					}
-					break;
-				}
-			case AtResultTypeValue:
-				{
-					for(ArrayValue::Iterator i(array); i; i.next() )
-						if(i.value() &&!(pos--)){
+						case AtResultTypeValue:
 							r.write(*i.value());
 							break;
-						}
-					break;
-				}
-			case AtResultTypeHash:
-				{
-					for(ArrayValue::Iterator i(array); i; i.next() )
-						if(i.value() &&!(pos--)){
+						case AtResultTypeHash:
 							r.write(SingleElementHash(i.key(), i.value()));
 							break;
-						}
+					}
 					break;
 				}
+			}
 		}
 	}
 }
@@ -393,30 +978,29 @@ static void _select(Request& r, MethodPa
 	ArrayValue& result_array=result->array();
 
 	if(limit>0){
-
 		if(reverse){
 			for(ArrayValue::ReverseIterator i(source_array); i; ){
-				Value *value=i.prev(); // here for correct i.key()
-				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, value);
-
-				bool condition=r.process(vcondition).as_bool();
+				if(Value *value=i.prev()){ // here for correct i.key()
+					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, value);
 
-				if(r.check_skip_break())
-					break;
+					bool condition=r.process(vcondition).as_bool();
 
-				if(condition){
-					result_array+=value;
-					if(!--limit)
+					if(r.check_skip_break())
 						break;
+
+					if(condition){
+						result_array+=value;
+						if(!--limit)
+							break;
+					}
 				}
 			}
 		} else {
 			for(ArrayValue::Iterator i(source_array); i; i.next() ){
-				Value *value=i.value();
-				if(value){
+				if(Value *value=i.value()){
 					if(key_var_name)
 						r.put_element(caller, *key_var_name, new VString(*new String(i.key(), String::L_TAINTED)));
 					if(value_var_name)
@@ -437,15 +1021,14 @@ static void _select(Request& r, MethodPa
 		}
 	}
 
+	result_array.confirm_all_used();
 	r.write(*result);
 }
 
-static void _reverse(Request& r, MethodParams& params) {
-	VArray& self=GET_SELF(r, VArray);
-	ArrayValue& source_array=self.array();
-	size_t count=source_array.count();
+static void _reverse(Request& r, MethodParams&) {
+	ArrayValue& source_array=GET_SELF(r, VArray).array();
 
-	VArray& result=*new VArray(count);
+	VArray& result=*new VArray(source_array.count());
 	ArrayValue& result_array=result.array();
 
 	for(ArrayValue::ReverseIterator i(source_array); i; ){
@@ -455,36 +1038,52 @@ static void _reverse(Request& r, MethodP
 	r.write(result);
 }
 
+static void _compact(Request& r, MethodParams& params) {
+	bool compact_undef=false;
+	if(params.count()>0){
+		const String& what=params.as_string(0, PARAMETER_MUST_BE_STRING);
+		if(!what.is_empty()){
+			if(what != "undef")
+				throw Exception(PARSER_RUNTIME, &what, "param must be empty or 'undef'");
+			compact_undef=true;
+		}
+	}
+	ArrayValue& array=GET_SELF(r, VArray).array();
+	array.compact(compact_undef);
+	array.confirm_all_used();
+}
 
-static void _rename(Request& r, MethodParams& params) {}
 
 // constructor
 
 MArray::MArray(): Methoded(VARRAY_TYPE) {
-//	set_base(hash_class);
 
-	// ^array::create[[copy_from]]
-	add_native_method("create", Method::CT_DYNAMIC, _create_or_add, 0, 1);
+	// ^array::copy[[copy_from]]
+	add_native_method("copy", Method::CT_DYNAMIC, _copy_or_add, 0, 1);
 	// ^array.add[add_from]
-	add_native_method("add", Method::CT_DYNAMIC, _create_or_add, 1, 1);
-
-	// ^array.sub[sub_from]
-	add_native_method("sub", Method::CT_DYNAMIC, _sub, 1, 1);
-	// ^array.union[b] = array
-	add_native_method("union", Method::CT_DYNAMIC, _union, 1, 1);
-	// ^array.intersection[b][options array] = array
-	add_native_method("intersection", Method::CT_DYNAMIC, _intersection, 1, 2);
-	// ^array.intersects[b] = bool
-	add_native_method("intersects", Method::CT_DYNAMIC, _intersects, 1, 1);
+	add_native_method("add", Method::CT_DYNAMIC, _copy_or_add, 1, 1);
+	// ^array.join[join_from[;options]]
+	add_native_method("join", Method::CT_DYNAMIC, _join, 1, 2);
 
+	// ^array::create[value;value]
+	add_native_method("create", Method::CT_DYNAMIC, _create_or_append, 0, 10000);
 	// ^array.append[value;value]
-	add_native_method("append", Method::CT_DYNAMIC, _append, 1, 10000);
-
+	add_native_method("append", Method::CT_DYNAMIC, _create_or_append, 1, 10000);
 	// ^array.insert[index;value...]
 	add_native_method("insert", Method::CT_DYNAMIC, _insert, 2, 10000);
 
+	// ^array.left(n)
+	add_native_method("left", Method::CT_DYNAMIC, _left, 1, 1);
+	// ^array.right(n)
+	add_native_method("right", Method::CT_DYNAMIC, _right, 1, 1);
+	// ^array.mid(p)
+	// ^array.mid(p;n)
+	add_native_method("mid", Method::CT_DYNAMIC, _mid, 1, 2);
+
 	// ^array.delete[index]
 	add_native_method("delete", Method::CT_DYNAMIC, _delete, 0, 1);
+	// ^array.remove[index]
+	add_native_method("remove", Method::CT_DYNAMIC, _remove, 1, 1);
 
 	// ^array.contains[index]
 	add_native_method("contains", Method::CT_DYNAMIC, _contains, 1, 1);
@@ -495,11 +1094,13 @@ MArray::MArray(): Methoded(VARRAY_TYPE)
 	// ^array._keys[[column name]]
 	add_native_method("_keys", Method::CT_DYNAMIC, _keys, 0, 1);
 
-	// ^array._count[]
-	add_native_method("_count", Method::CT_DYNAMIC, _count, 0, 0);
+	// ^array._count[[all]]
+	add_native_method("_count", Method::CT_DYNAMIC, _count, 0, 1);
 
+	// ^array.for[index;value]{code}[delim]
+	add_native_method("for", Method::CT_DYNAMIC, _for, 3, 3+1);
 	// ^array.foreach[index;value]{code}[delim]
-	add_native_method("foreach", Method::CT_DYNAMIC, _foreach, 2+1, 2+1+1);
+	add_native_method("foreach", Method::CT_DYNAMIC, _foreach, 3, 3+1);
 
 	// ^array.sort[index;value]{string-key-maker}[[asc|desc]]
 	// ^array.sort[index;value](numeric-key-maker)[[asc|desc]]
@@ -511,18 +1112,17 @@ MArray::MArray(): Methoded(VARRAY_TYPE)
 	// ^array.reverse[]
 	add_native_method("reverse", Method::CT_DYNAMIC, _reverse, 0, 0);
 
+	// ^array.compact[[undef]]
+	add_native_method("compact", Method::CT_DYNAMIC, _compact, 0, 1);
+
 	// ^array._at[first|last[;'key'|'value'|'hash']]
 	// ^array._at([-+]offset)[['key'|'value'|'hash']]
 	add_native_method("_at", Method::CT_DYNAMIC, _at, 1, 2);
 
-	// ^array.rename[from;to]
-	// ^array.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);
-	add_native_method("count", Method::CT_DYNAMIC, _count, 0, 0);
+	add_native_method("count", Method::CT_DYNAMIC, _count, 0, 1);
 	add_native_method("at", Method::CT_DYNAMIC, _at, 1, 2);
 #endif