--- parser3/src/classes/array.C	2024/09/21 15:23:23	1.7
+++ parser3/src/classes/array.C	2024/10/23 23:53:06	1.23
@@ -17,7 +17,7 @@
 #include "pa_vbool.h"
 #include "pa_vmethod_frame.h"
 
-volatile const char * IDENT_ARRAY_C="$Id: array.C,v 1.7 2024/09/21 15:23:23 moko Exp $";
+volatile const char * IDENT_ARRAY_C="$Id: array.C,v 1.23 2024/10/23 23:53:06 moko Exp $";
 
 // class
 
@@ -46,17 +46,24 @@ static void _create_or_add(Request& r, M
 
 		if(VArray* src=dynamic_cast<VArray*>(&vsrc)) {
 			if(src==&self)
-				throw Exception(PARSER_RUNTIME, 0, "source and destination are the same array");
-			self_array.append(src->array());
+				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.get_hash();
+			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.invalidate();
+		self_array.invalidate();
 	}
 }
 
@@ -74,11 +81,13 @@ static ArrayValue::Action_options get_ac
 
 	if(Value* voffset=options->get(sql_offset_name)) {
 		valid_options++;
-		result.offset=r.process(*voffset).as_int();
+		int offset=r.process(*voffset).as_int();
+		result.offset=offset < 0 ? 0 : offset;
 	}
 	if(Value* vlimit=options->get(sql_limit_name)) {
 		valid_options++;
-		result.limit=r.process(*vlimit).as_int();
+		int limit=r.process(*vlimit).as_int();
+		result.limit=limit < 0 ? 0: limit;
 	}
 
 	if(valid_options!=options->count())
@@ -117,7 +126,7 @@ static void _join(Request& r, MethodPara
 			}
 		}
 	} else {
-		HashStringValue* src_hash=vsrc.get_hash();
+		HashStringValue* src_hash=vsrc.as_hash("param must be array or");
 		if(!src_hash)
 			return;
 		if(o.defined){
@@ -136,18 +145,432 @@ static void _join(Request& r, MethodPara
 			}
 		}
 	}
-	self.invalidate();
+	self_array.invalidate();
 }
 
-static void _sql(Request& r, MethodParams& params) {}
+#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;
+			}
 
-static void _sub(Request& r, MethodParams& params) {}
+			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;
+		}
+	}
+};
 
-static void _union(Request& r, MethodParams& params) {}
+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) {
+	}
 
-static void _intersection(Request& r, MethodParams& params) {}
+	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;
+		}
+	}
 
-static void _intersects(Request& r, MethodParams& params) {}
+	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();
+			}
+		}
+		result_array.confirm_all_used();
+		r.write(*result);
+	} else {
+		r.write(*new VArray);
+	}
+}
+
+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);
+
+	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 _mid(Request& r, MethodParams& params) {
+	int begin=params.as_int(0, "p must be int", r);
+
+	if(begin<0)
+		throw Exception(PARSER_RUNTIME, 0,  "p(%d) must be >=0", begin);
+
+	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;
@@ -186,43 +609,41 @@ static void _count(Request& r, MethodPar
 }
 
 static void _append(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();
 
 	for(int i=0; i<count; i++){
 		array+=&r.process(params[i]);
 	}
-	self.invalidate();
+	array.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, 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) {
-	VArray& self=GET_SELF(r, VArray);
+	ArrayValue& array=GET_SELF(r, VArray).array();
 	if(params.count()>0)
-		self.array().clear(VArray::index(params.as_int(0, PARAM_INDEX, r)));
+		array.clear(VArray::index(params.as_int(0, PARAM_INDEX, r)));
 	else
-		self.array().clear();
-	self.invalidate();
+		array.clear();
+	array.invalidate();
 }
 
 static void _remove(Request& r, MethodParams& params) {
-	VArray& self=GET_SELF(r, VArray);
-	self.array().remove(VArray::index(params.as_int(0, PARAM_INDEX, r)));
-	self.invalidate();
+	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) {
@@ -435,6 +856,7 @@ static void _sort(Request& r, MethodPara
 		for(pos=0; pos<count; pos++)
 			array+=seq[pos].array_data;
 
+	array.invalidate();
 	delete[] seq;
 }
 
@@ -444,7 +866,7 @@ enum AtResultType {
 	AtResultTypeHash = 2
 };
 
-inline Value& SingleElementHash(String::Body akey, Value* avalue) {
+static Value& SingleElementHash(String::Body akey, Value* avalue) {
 	Value& result=*new VHash;
 	result.put_element(*new String(akey, String::L_TAINTED), avalue);
 	return result;
@@ -482,35 +904,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[pos]);
+					break;
+				case AtResultTypeHash:
+					r.write(SingleElementHash(pa_uitoa(pos), array[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;
 				}
+			}
 		}
 	}
 }
@@ -595,10 +1017,11 @@ static void _select(Request& r, MethodPa
 		}
 	}
 
+	result_array.confirm_all_used();
 	r.write(*result);
 }
 
-static void _reverse(Request& r, MethodParams& params) {
+static void _reverse(Request& r, MethodParams&) {
 	ArrayValue& source_array=GET_SELF(r, VArray).array();
 
 	VArray& result=*new VArray(source_array.count());
@@ -611,32 +1034,37 @@ static void _reverse(Request& r, MethodP
 	r.write(result);
 }
 
+static void _compact(Request& r, MethodParams&) {
+	GET_SELF(r, VArray).array().compact();
+}
+
 
 // constructor
 
 MArray::MArray(): Methoded(VARRAY_TYPE) {
 
-	// ^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, _create_or_add, 0, 1);
 	// ^array.add[add_from]
 	add_native_method("add", Method::CT_DYNAMIC, _create_or_add, 1, 1);
 	// ^array.join[join_from[;options]]
 	add_native_method("join", Method::CT_DYNAMIC, _join, 1, 2);
 
-	// ^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);
-
+	// ^array::create[value;value]
+	add_native_method("create", Method::CT_DYNAMIC, _append, 0, 10000);
 	// ^array.append[value;value]
 	add_native_method("append", Method::CT_DYNAMIC, _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]
@@ -669,6 +1097,9 @@ MArray::MArray(): Methoded(VARRAY_TYPE)
 	// ^array.reverse[]
 	add_native_method("reverse", Method::CT_DYNAMIC, _reverse, 0, 0);
 
+	// ^array.compact[]
+	add_native_method("compact", Method::CT_DYNAMIC, _compact, 0, 0);
+
 	// ^array._at[first|last[;'key'|'value'|'hash']]
 	// ^array._at([-+]offset)[['key'|'value'|'hash']]
 	add_native_method("_at", Method::CT_DYNAMIC, _at, 1, 2);
@@ -676,7 +1107,7 @@ MArray::MArray(): Methoded(VARRAY_TYPE)
 #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