--- parser3/src/classes/table.C	2002/03/15 10:08:13	1.145
+++ parser3/src/classes/table.C	2002/12/09 12:19:16	1.170
@@ -3,10 +3,10 @@
 
 	Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
-
-	$Id: table.C,v 1.145 2002/03/15 10:08:13 paf Exp $
 */
 
+static const char* IDENT_TABLE_C="$Date: 2002/12/09 12:19:16 $";
+
 #include "classes.h"
 #include "pa_common.h"
 #include "pa_request.h"
@@ -15,10 +15,6 @@
 #include "pa_sql_connection.h"
 #include "pa_vbool.h"
 
-// defines
-
-#define TABLE_CLASS_NAME "table"
-
 // class
 
 class MTable : public Methoded {
@@ -34,19 +30,64 @@ public: // Methoded
 
 // methods
 
+static void get_copy_options(Request& r, const String& method_name, MethodParams *params, int param_index,
+							 const Table& source,
+							 int& offset,
+							 int& limit) {
+	offset=0;
+	limit=0;
+	if(params->size()<=param_index)
+		return;
+
+	Value& voptions=params->as_no_junction(param_index, "options must be hash, not code");
+	if(!voptions.is_string()) {
+		if(Hash *options=voptions.get_hash(&method_name)) {
+			int valid_options=0;
+			if(Value *voffset=(Value *)options->get(*sql_offset_name)) {
+				valid_options++;
+				if(voffset->is_string()) {
+					const String& soffset=*voffset->get_string();
+					if(soffset == "cur")
+						offset=source.current();
+					else
+						throw Exception("parser.runtime",
+							&soffset,
+							"must be 'cur' string or expression");
+				} else 
+					offset=r.process_to_value(*voffset).as_int();
+			}
+			if(Value *vlimit=(Value *)options->get(*sql_limit_name)) {
+				valid_options++;
+				limit=r.process_to_value(*vlimit).as_int();
+			}
+			if(valid_options!=options->size())
+				throw Exception("parser.runtime",
+					&method_name,
+					"called with invalid option");
+		} else
+			throw Exception("parser.runtime",
+				&method_name,
+				"options must be hash");
+	}
+	if(!limit) // zero limit = sould be 'nothing to copy', for methods zero means 'all'
+		limit=-1; // thus fixing
+}
+
 static void _create(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
-	// clone?
-	if(params->size()==1) 
-		if(const Table *source=params->get(0).get_table()) {
-			static_cast<VTable *>(r.self)->set_table(*new(pool) Table(*source));
-			return;
-		}
+	// clone/copy part?
+	if(const Table *source=params->get(0).get_table()) {
+		int offset, limit;
+		get_copy_options(r, method_name, params, 1, *source, 
+			offset, limit);
+		static_cast<VTable *>(r.get_self())->set_table(*new(pool) Table(pool, *source, offset, limit));
+		return;
+	}
 
 	// data is last parameter
 	Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
 	const String& data=
-		r.process(params->as_junction(params->size()-1, "body must be code")).as_string();
+		r.process_to_string(params->as_junction(params->size()-1, "body must be code"));
 
 	size_t pos_after=0;
 	// parse columns
@@ -79,17 +120,24 @@ static void _create(Request& r, const St
 	}
 
 	// replace any previous table value
-	static_cast<VTable *>(r.self)->set_table(table);
+	static_cast<VTable *>(r.get_self())->set_table(table);
 }
 
 static void _load(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
-	// filename is last parameter
-	Value& vfile_name=params->as_no_junction(params->size()-1, 
-		"file name must not be code");
-
+	const String& first_param=params->as_string(0, "file name must be string");
+	int filename_param_index=0;
+	bool nameless=first_param=="nameless";
+	if(nameless)
+		filename_param_index++;
+	int options_param_index=filename_param_index+1;
+	
 	// loading text
-	char *data=file_read_text(pool, r.absolute(vfile_name.as_string()));
+	char *data=file_read_text(pool, 
+		r.absolute(params->as_string(filename_param_index, "file name must be string")),
+		true,
+		options_param_index<params->size()?params->as_no_junction(options_param_index, "additional params must be hash").get_hash(&method_name):0
+	);
 
 	// parse columns
 	Array *columns;
@@ -98,7 +146,7 @@ static void _load(Request& r, const Stri
 	const char *file=origin.file;
 	uint line=origin.line;
 #endif
-	if(params->size()==2) {
+	if(nameless) {
 		columns=0; // nameless
 	} else {
 		columns=new(pool) Array(pool);
@@ -137,16 +185,16 @@ static void _load(Request& r, const Stri
 	};
 
 	// replace any previous table value
-	static_cast<VTable *>(r.self)->set_table(table);
+	static_cast<VTable *>(r.get_self())->set_table(table);
 }
 
-/// @todo "z\nz" "zzz""zz"
+/// @todo "x\nx" "xxx""xx"
 static void _save(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
 	Value& vfile_name=params->as_no_junction(params->size()-1, 
 		"file name must not be code");
 
-	Table& table=static_cast<VTable *>(r.self)->table();
+	Table& table=static_cast<VTable *>(r.get_self())->table(&method_name);
 
 	bool do_append=false;
 	String sdata(pool);
@@ -178,7 +226,7 @@ static void _save(Request& r, const Stri
 		else if(mode=="nameless")
 			/*ok, already skipped names output*/;
 		else
-			throw Exception(0, 0,
+			throw Exception("parser.runtime",
 				&mode,
 				"unknown mode, must be 'append'");
 
@@ -188,8 +236,9 @@ static void _save(Request& r, const Stri
 	while(i.has_next()) {
 		Array_iter c(*static_cast<Array *>(i.next()));
 		while(c.has_next()) {
-			sdata.append(*c.next_string(), //*static_cast<String *>(row->quick_get(column)), 
-				String::UL_TABLE);
+			if(const String *s=c.next_string())
+				sdata.append(*s,
+					String::UL_TABLE);
 			if(c.has_next())
 				sdata.APPEND_CONST("\t");
 		}
@@ -203,21 +252,19 @@ static void _save(Request& r, const Stri
 
 static void _count(Request& r, const String& method_name, MethodParams *) {
 	Pool& pool=r.pool();
-	Value& value=*new(pool) VInt(pool, static_cast<VTable *>(r.self)->table().size());
-	value.set_name(method_name);
-	r.write_no_lang(value);
+	int result=static_cast<VTable *>(r.get_self())->table(&method_name).size();
+	r.write_no_lang(*new(pool) VInt(pool, result));
 }
 
 static void _line(Request& r, const String& method_name, MethodParams *) {
 	Pool& pool=r.pool();
-	Value& value=*new(pool) VInt(pool, 1+static_cast<VTable *>(r.self)->table().current());
-	value.set_name(method_name);
-	r.write_no_lang(value);
+	int result=1+static_cast<VTable *>(r.get_self())->table(&method_name).current();
+	r.write_no_lang(*new(pool) VInt(pool, result));
 }
 
 static void _offset(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
-	Table& table=static_cast<VTable *>(r.self)->table();
+	Table& table=static_cast<VTable *>(r.get_self())->table(&method_name);
 	if(params->size()) {
 		bool absolute=false;
 		if(params->size()>1) {
@@ -227,18 +274,15 @@ static void _offset(Request& r, const St
 		    else if(whence=="set")
 				absolute=true;
 		    else
-				throw Exception(0, 0,
+				throw Exception("parser.runtime",
 					&whence,
 					"is invalid whence, valid are 'cur' or 'set'");
-		}		    
+		}
 		
 		Value& offset_expr=params->as_junction(params->size()-1, "offset must be expression");
-		table.offset(absolute, r.process(offset_expr).as_int());
-	} else {
-		Value& value=*new(pool) VInt(pool, table.current());
-		value.set_name(method_name);
-		r.write_no_lang(value);
-	}
+		table.offset(absolute, r.process_to_value(offset_expr).as_int());
+	} else
+		r.write_no_lang(*new(pool) VInt(pool, table.current()));
 }
 
 static void _menu(Request& r, const String& method_name, MethodParams *params) {
@@ -246,32 +290,35 @@ static void _menu(Request& r, const Stri
 	
 	Value *delim_maybe_code=params->size()>1?&params->get(1):0;
 
-	VTable& vtable=*static_cast<VTable *>(r.self);
-	Table& table=vtable.table();
+	Table& table=static_cast<VTable *>(r.get_self())->table(&method_name);
 	bool need_delim=false;
 	int saved_current=table.current();
 	int size=table.size();
 	for(int row=0; row<size; row++) {
 		table.set_current(row);
 
-		Value& processed_body=r.process(body_code);
-		if(delim_maybe_code) { // delimiter set?
-			const String *string=processed_body.get_string();
-			if(need_delim && string && string->size()) // need delim & iteration produced string?
+		StringOrValue sv_processed=r.process(body_code);
+		const String *s_processed=sv_processed.get_string();
+		if(delim_maybe_code && s_processed && s_processed->size()) { // delimiter set and we have body
+			if(need_delim) // need delim & iteration produced string?
 				r.write_pass_lang(r.process(*delim_maybe_code));
 			need_delim=true;
 		}
-		r.write_pass_lang(processed_body);
+		r.write_pass_lang(sv_processed);
 	}
 	table.set_current(saved_current);
 }
 
 #ifndef DOXYGEN
 struct Row_info {
+	Request *r;
 	Table *table;
+	Value *key_code;
 	int key_field;
 	Array *value_fields;
 	Hash *hash;
+	bool distinct;
+	int row;
 };
 #endif
 static void table_row_to_hash(Array::Item *value, void *info) {
@@ -279,33 +326,64 @@ static void table_row_to_hash(Array::Ite
 	Row_info& ri=*static_cast<Row_info *>(info);
 	Pool& pool=ri.table->pool();
 
-	if(ri.key_field<row.size()) {
-		VHash& result=*new(pool) VHash(pool);
-		Hash& hash=*result.get_hash(0);
-		for(int i=0; i<ri.value_fields->size(); i++) {
-			int value_field=ri.value_fields->get_int(i);
-			if(value_field<row.size())
-				hash.put(
-					*ri.table->columns()->get_string(value_field), 
-					new(pool) VString(*row.get_string(value_field)));
-		}
+	const String *key;
+	if(ri.key_code) {
+		ri.table->set_current(ri.row++); // change context row
+		StringOrValue sv_processed=ri.r->process(*ri.key_code);
+		key=&sv_processed.as_string();
+	} else
+		key=ri.key_field<row.size()?row.get_string(ri.key_field):0;
+
+	if(!key)
+		return; // ignore rows without key [too-short-record_array if-indexed]
 		
-		ri.hash->put(*row.get_string(ri.key_field), &result);
+	VHash& result=*new(pool) VHash(pool);
+	Hash& hash=*result.get_hash(0);
+	for(int i=0; i<ri.value_fields->size(); i++) {
+		int value_field=ri.value_fields->get_int(i);
+		if(value_field<row.size())
+			hash.put(
+				*ri.table->columns()->get_string(value_field), 
+				new(pool) VString(*row.get_string(value_field)));
 	}
+
+	if(ri.hash->put_dont_replace(*key, &result)) // put. existed?
+		if(!ri.distinct)
+			throw Exception("parser.runtime",
+				key,
+				"duplicate key");
 }
 static void _hash(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
-	Table& self_table=static_cast<VTable *>(r.self)->table();
+	Table& self_table=static_cast<VTable *>(r.get_self())->table(&method_name);
 	Value& result=*new(pool) VHash(pool);
-	if(const Array *columns=self_table.columns()) 
-		if(columns->size()>1) {
-			const String& key_field_name=params->as_no_junction(0, 
-				"key field name must not be code").as_string();
-			int key_field=self_table.column_name2index(key_field_name, true);
+	if(const Array *columns=self_table.columns())
+		if(columns->size()>0) {
+			bool distinct=false;
+			int param_index=params->size()-1;
+			if(param_index>0) {
+				if(Hash *options=
+					params->as_no_junction(param_index, "param must not be code").get_hash(0)) {
+					--param_index;
+					int valid_options=0;
+					if(Value *vdistinct=(Value *)options->get(*sql_distinct_name)) {
+						valid_options++;
+						distinct=r.process_to_value(*vdistinct).as_bool();
+					}
+					if(valid_options!=options->size())
+						throw Exception("parser.runtime",
+							&method_name,
+							"called with invalid option");
+				}
+			}
+			if(param_index==2) // bad options param type
+				throw Exception("parser.runtime",
+					&method_name,
+					"options must be hash");
 
 			Array value_fields(pool);
-			if(params->size()>1) {
-				Value& value_fields_param=params->as_no_junction(1, "value field(s) must not be code");
+			if(param_index>0) {
+				Value& value_fields_param=params->as_no_junction(param_index, "value field(s) must not be code");
 				if(value_fields_param.is_string()) {
 					value_fields+=self_table.column_name2index(value_fields_param.as_string(), true);
 				} else if(Table *value_fields_table=value_fields_param.get_table()) {
@@ -315,7 +393,7 @@ static void _hash(Request& r, const Stri
 						value_fields+=self_table.column_name2index(value_field_name, true);
 					}
 				} else
-					throw Exception(0, 0,
+					throw Exception("parser.runtime",
 						&method_name,
 						"value field(s) must be string or self_table"
 					);
@@ -324,11 +402,17 @@ static void _hash(Request& r, const Stri
 					value_fields+=i;
 			}
 
-			// integers: key_field & value_fields
-			Row_info row_info={&self_table, key_field, &value_fields, result.get_hash(0)};
+			Value& key_param=params->get(0);
+			Value *key_code=key_param.get_junction()?&key_param:0;
+			int key_field=key_code?-1
+				:self_table.column_name2index(key_param.as_string(), true);
+
+			Row_info row_info={&r, &self_table, key_code, key_field, &value_fields, result.get_hash(0), distinct};
+
+			int saved_current=self_table.current();
 			self_table.for_each(table_row_to_hash, &row_info);
+			self_table.set_current(saved_current);
 		}
-	result.set_name(method_name);
 	r.write_no_lang(result);
 }
 
@@ -365,7 +449,7 @@ static void _sort(Request& r, const Stri
 		reverse=params->as_no_junction(1, "order must not be code").as_string()=="desc":
 		false; // default=asc
 
-	Table& old_table=static_cast<VTable *>(r.self)->table();
+	Table& old_table=static_cast<VTable *>(r.get_self())->table(&method_name);
 	Table& new_table=*new(pool) Table(pool, &method_name, old_table.columns());
 
 	Table_seq_item *seq=(Table_seq_item *)pool.malloc(sizeof(Table_seq_item)*old_table.size());
@@ -379,7 +463,7 @@ static void _sort(Request& r, const Stri
 		old_table.set_current(i);
 		// calculate key value
 		seq[i].row=(MethodParams *)old_table.get(i);
-		Value& value=*r.process(key_maker).as_expr_result(true/*return string as-is*/);
+		Value& value=*r.process_to_value(key_maker).as_expr_result(true/*return string as-is*/);
 		if(i==0) // determining key values type by first one
 			key_values_are_strings=value.is_string();
 
@@ -399,25 +483,24 @@ static void _sort(Request& r, const Stri
 		new_table+=seq[reverse?old_table.size()-1-i:i].row;
 
 	// replace any previous table value
-	static_cast<VTable *>(r.self)->set_table(new_table);
+	static_cast<VTable *>(r.get_self())->set_table(new_table);
 }
 
 static bool _locate_expression(Request& r, const String& method_name, MethodParams *params) {
 	if(params->size()>1)
-		throw Exception(0, 0, 
+		throw Exception("parser.runtime", 
 			&method_name,
 			"locate by expression has only one parameter - expression");
 
 	Value& expression_code=params->as_junction(0, "must be expression");
 
-	VTable& vtable=*static_cast<VTable *>(r.self);
-	Table& table=vtable.table();
+	Table& table=static_cast<VTable *>(r.get_self())->table(&method_name);
 	int saved_current=table.current();
 	int size=table.size();
 	for(int row=0; row<size; row++) {
 		table.set_current(row);
 
-		if(r.process(expression_code).as_bool())
+		if(r.process_to_value(expression_code).as_bool())
 			return true;
 	}
 	table.set_current(saved_current);
@@ -425,12 +508,11 @@ static bool _locate_expression(Request&
 }
 static bool _locate_name_value(Request& r, const String& method_name, MethodParams *params) {
 	if(params->size()>2)
-		throw Exception(0, 0, 
+		throw Exception("parser.runtime", 
 			&method_name,
 			"locate by name and value has only two parameters - name and value");
 
-	VTable& vtable=*static_cast<VTable *>(r.self);
-	Table& table=vtable.table();
+	Table& table=static_cast<VTable *>(r.get_self())->table(&method_name);
 	return table.locate(
 		params->as_string(0, "column name must be string"),
 		params->as_string(1, "value must be string")
@@ -438,19 +520,15 @@ static bool _locate_name_value(Request&
 }
 static void _locate(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
-	Value& result=*new(pool) VBool(pool, 
-		params->get(0).get_junction()?
+	bool result=params->get(0).get_junction()?
 		_locate_expression(r, method_name, params) :
-		_locate_name_value(r, method_name, params));
-	result.set_name(method_name);
-	r.write_no_lang(result);
+		_locate_name_value(r, method_name, params);
+	r.write_no_lang(*new(pool) VBool(pool, result));
 }
 
 static void _flip(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
-	VTable& vtable=*static_cast<VTable *>(r.self);
-
-	Table& old_table=*vtable.get_table();
+	Table& old_table=static_cast<VTable *>(r.get_self())->table(&method_name);
 	Table& new_table=*new(pool) Table(pool, &method_name, 0/*nameless*/);
 	if(old_table.size())
 		if(int old_cols=old_table.at(0).size()) 
@@ -471,14 +549,13 @@ static void _append(Request& r, const St
 	// data
 	Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
 	const String& string=
-		r.process(params->as_junction(0, "body must be code")).as_string();
+		r.process_to_string(params->as_junction(0, "body must be code"));
 
 	// parse cells
 	Array& row=*new(pool) Array(pool);
 	string.split(row, 0, "\t", 1, String::UL_AS_IS);
 
-	VTable& vtable=*static_cast<VTable *>(r.self);
-	vtable.table()+=&row;
+	static_cast<VTable *>(r.get_self())->table(&method_name)+=&row;
 }
 
 static void _join(Request& r, const String& method_name, MethodParams *params) {
@@ -486,20 +563,28 @@ static void _join(Request& r, const Stri
 
 	Table *maybe_src=params->as_no_junction(0, "table ref must not be code").get_table();
 	if(!maybe_src)
-		throw Exception(0, 0, 
+		throw Exception("parser.runtime", 
 			&method_name, 
 			"source is not a table");
 
 	Table& src=*maybe_src;
-	Table& dest=static_cast<VTable *>(r.self)->table();
+	Table& dest=static_cast<VTable *>(r.get_self())->table(&method_name);
 	if(&src == &dest)
-		throw Exception(0, 0, 
+		throw Exception("parser.runtime", 
 			&method_name, 
 			"source and destination are same table");
 
+	int offset, limit;
+	get_copy_options(r, method_name, params, 1, src, 
+		offset, limit);
+
 	if(const Array *dest_columns=dest.columns()) { // dest is named
 		int saved_src_current=src.current();
-		for(int src_row=0; src_row<src.size(); src_row++) {
+		int m=src.size()-offset;
+		if(!limit || limit>m)
+			limit=m;
+		int end=offset+limit;
+		for(int src_row=offset; src_row<end; src_row++) {
 			src.set_current(src_row);
 			Array& dest_row=*new(pool) Array(pool);
 			for(int dest_column=0; dest_column<dest_columns->size(); dest_column++) {
@@ -516,7 +601,7 @@ static void _join(Request& r, const Stri
 }
 
 #ifndef DOXYGEN
-class Table_sql_event_handlers : public SQL_Driver_query_event_handlers {
+class Table_sql_event_handlers: public SQL_Driver_query_event_handlers {
 public:
 	Table_sql_event_handlers(Pool& apool, const String& amethod_name,
 		const String& astatement_string, const char *astatement_cstr) :
@@ -530,26 +615,50 @@ public:
 	{
 	}
 
-	void add_column(void *ptr, size_t size) {
-		String *column=new(pool) String(pool);
-		column->APPEND_TAINTED(
-			(const char *)ptr, size, 
-			statement_cstr, 0);
-		columns+=column;
-	}
-	void before_rows() { 
-		table=new(pool) Table(pool, &method_name, &columns);
-	}
-	void add_row() {
-		(*table)+=(row=new(pool) Array(pool));
-	}
-	void add_row_cell(void *ptr, size_t size) {
-		String *cell=new(pool) String(pool);
-		if(size)
-			cell->APPEND_TAINTED(
+	bool add_column(SQL_Error& error, void *ptr, size_t size) {
+		try {
+			String *column=new(pool) String(pool);
+			column->APPEND_TAINTED(
 				(const char *)ptr, size, 
-				statement_cstr, table->size()-1);
-		(*row)+=cell;
+				statement_cstr, 0);
+			columns+=column;
+			return false;
+		} catch(...) {
+			error=SQL_Error("exception occured in Table_sql_event_handlers::add_column");
+			return true;
+		}
+	}
+	bool before_rows(SQL_Error& error) { 
+		try {
+			table=new(pool) Table(pool, &method_name, &columns);
+			return false;
+		} catch(...) {
+			error=SQL_Error("exception occured in Table_sql_event_handlers::before_rows");
+			return true;
+		}
+	}
+	bool add_row(SQL_Error& error) {
+		try {
+			(*table)+=(row=new(pool) Array(pool));
+			return false;
+		} catch(...) {
+			error=SQL_Error("exception occured in Table_sql_event_handlers::add_row");
+			return true;
+		}
+	}
+	bool add_row_cell(SQL_Error& error, void *ptr, size_t size) {
+		try {
+			String *cell=new(pool) String(pool);
+			if(size)
+				cell->APPEND_TAINTED(
+					(const char *)ptr, size, 
+					statement_cstr, table->size()-1);
+			(*row)+=cell;
+			return false;
+		} catch(...) {
+			error=SQL_Error("exception occured in Table_sql_event_handlers::add_row_cell");
+			return true;
+		}
 	}
 
 private:
@@ -571,33 +680,42 @@ static void _sql(Request& r, const Strin
 	ulong offset=0;
 	if(params->size()>1) {
 		Value& voptions=params->as_no_junction(1, "options must be hash, not code");
-		if(voptions.is_defined())
+		if(!voptions.is_string())
 			if(Hash *options=voptions.get_hash(&method_name)) {
-				if(Value *vlimit=(Value *)options->get(*sql_limit_name))
-					limit=(ulong)r.process(*vlimit).as_double();
-				if(Value *voffset=(Value *)options->get(*sql_offset_name))
-					offset=(ulong)r.process(*voffset).as_double();
+				int valid_options=0;
+				if(Value *vlimit=(Value *)options->get(*sql_limit_name)) {
+					valid_options++;
+					limit=(ulong)r.process_to_value(*vlimit).as_double();
+				}
+				if(Value *voffset=(Value *)options->get(*sql_offset_name)) {
+					valid_options++;
+					offset=(ulong)r.process_to_value(*voffset).as_double();
+				}
+				if(valid_options!=options->size())
+					throw Exception("parser.runtime",
+						&method_name,
+						"called with invalid option");
 			} else
-				throw Exception(0, 0,
+				throw Exception("parser.runtime",
 					&method_name,
 					"options must be hash");
 	}
 
 	Temp_lang temp_lang(r, String::UL_SQL);
-	const String& statement_string=r.process(statement).as_string();
+	const String& statement_string=r.process_to_string(statement);
 	const char *statement_cstr=
 		statement_string.cstr(String::UL_UNSPECIFIED, r.connection(&method_name));
 	Table_sql_event_handlers handlers(pool, method_name,
 		statement_string, statement_cstr);
-	try {
 #ifdef RESOURCES_DEBUG
 	struct timeval mt[2];
 	//measure:before
 	gettimeofday(&mt[0],NULL);
 #endif	
-		r.connection(&method_name)->query(
-			statement_cstr, offset, limit, 
-			handlers);
+	r.connection(&method_name)->query(
+		statement_cstr, offset, limit, 
+		handlers,
+		statement_string);
 	
 #ifdef RESOURCES_DEBUG
 		//measure:after connect
@@ -609,19 +727,13 @@ static void _sql(Request& r, const Strin
 	    
 	r.sql_request_time+=t[1]-t[0];
 #endif	    			
-	} catch(const Exception& e) { // query problem
-		// more specific source [were url]
-		throw Exception(e.type(), e.code(), 
-			&statement_string, 
-			"%s", e.comment());
-	}
 
 	Table *result=
 		handlers.table?handlers.table: // query resulted in table? return it
 		new(pool) Table(pool, &method_name, 0); // query returned no table, fake it
 
 	// replace any previous table value
-	static_cast<VTable *>(r.self)->set_table(*result);
+	static_cast<VTable *>(r.get_self())->set_table(*result);
 }
 
 static void _columns(Request& r, const String& method_name, MethodParams *) {
@@ -631,7 +743,7 @@ static void _columns(Request& r, const S
 	result_columns+=new(pool) String(pool, "column");
 	Table& result_table=*new(pool) Table(pool, &method_name, &result_columns);
 
-	Table& source_table=static_cast<VTable *>(r.self)->table();
+	Table& source_table=static_cast<VTable *>(r.get_self())->table(&method_name);
 	if(const Array *source_columns=source_table.columns()) {
 		Array_iter i(*source_columns);
 		while(i.has_next()) {
@@ -641,16 +753,40 @@ static void _columns(Request& r, const S
 		}
 	}
 
-	VTable& result=*new(pool) VTable(pool, &result_table);
-	result.set_name(method_name);
-	r.write_no_lang(result);
+	r.write_no_lang(*new(pool) VTable(pool, &result_table));
 }
 
-// constructor
+static void _select(Request& r, const String& method_name, MethodParams *params) {
+	Pool& pool=r.pool();
+
+	Value& vcondition=params->as_junction(0, "condition must be expression");
+
+	Table& source_table=static_cast<VTable *>(r.get_self())->table(&method_name);
+	Table& result_table=*new(pool) Table(pool, 
+		source_table.origin_string(), 
+		source_table.columns()
+	);
+
+	int saved_current=source_table.current();
+	int size=source_table.size();
+	for(int row=0; row<size; row++) {
+		source_table.set_current(row);
+
+		bool condition=r.process_to_value(vcondition, 
+				/*0/*no name* /,*/
+				false/*don't intercept string*/).as_bool();
+
+		if(condition) // ...condition is true=
+			result_table+=&source_table.at(row); // =green light to go to result
+	}
+	source_table.set_current(saved_current);
 
-MTable::MTable(Pool& apool) : Methoded(apool) {
-	set_name(*NEW String(pool(), TABLE_CLASS_NAME));
+	r.write_no_lang(*new(pool) VTable(pool, &result_table));
+}
+
+// constructor
 
+MTable::MTable(Pool& apool) : Methoded(apool, "table") {
 	// ^table::create{data}
 	// ^table::create[nameless]{data}
 	// ^table::create[table]
@@ -660,7 +796,7 @@ MTable::MTable(Pool& apool) : Methoded(a
 
 	// ^table::load[file]  
 	// ^table::load[nameless;file]
-	add_native_method("load", Method::CT_DYNAMIC, _load, 1, 2);
+	add_native_method("load", Method::CT_DYNAMIC, _load, 1, 3);
 
 	// ^table.save[file]  
 	// ^table.save[nameless;file]
@@ -683,7 +819,7 @@ MTable::MTable(Pool& apool) : Methoded(a
 
 	// ^table:hash[key field name]
 	// ^table:hash[key field name][value field name(s) string/table]
-	add_native_method("hash", Method::CT_DYNAMIC, _hash, 1, 2);
+	add_native_method("hash", Method::CT_DYNAMIC, _hash, 1, 3);
 
 	// ^table.sort{string-key-maker} ^table.sort{string-key-maker}[desc|asc]
 	// ^table.sort(numeric-key-maker) ^table.sort(numeric-key-maker)[desc|asc]
@@ -698,8 +834,8 @@ MTable::MTable(Pool& apool) : Methoded(a
 	// ^table.append{r{tab}e{tab}c{tab}o{tab}r{tab}d}
 	add_native_method("append", Method::CT_DYNAMIC, _append, 1, 1);
 
-	// ^table.join[table]
-	add_native_method("join", Method::CT_DYNAMIC, _join, 1, 1);
+	// ^table.join[table][$.limit(10) $.offset(1) $.offset[cur] ]
+	add_native_method("join", Method::CT_DYNAMIC, _join, 1, 2);
 
 
 	// ^table:sql[query]
@@ -708,6 +844,9 @@ MTable::MTable(Pool& apool) : Methoded(a
 
 	// ^table:columns[]
 	add_native_method("columns", Method::CT_DYNAMIC, _columns, 0, 0);
+
+	// ^table.select(expression) = table
+	add_native_method("select", Method::CT_DYNAMIC, _select, 1, 1);
 }
 
 // global variable