--- parser3/src/classes/table.C	2002/04/10 09:53:14	1.147
+++ parser3/src/classes/table.C	2002/08/06 14:23:22	1.157
@@ -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.147 2002/04/10 09:53:14 paf Exp $
 */
 
+static const char* IDENT_TABLE_C="$Date: 2002/08/06 14:23:22 $";
+
 #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,14 +30,47 @@ 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)) {
+			if(Value *voffset=(Value *)options->get(*sql_offset_name))
+				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))
+				limit=r.process_to_value(*vlimit).as_int();
+		} else
+			throw Exception("parser.runtime",
+				&method_name,
+				"options must be hash");
+}
+
 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.self)->set_table(*new(pool) Table(pool, *source, offset, limit));
+		return;
+	}
 
 	// data is last parameter
 	Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
@@ -188,8 +217,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,16 +233,14 @@ 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.self)->table().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.self)->table().current();
+	r.write_no_lang(*new(pool) VInt(pool, result));
 }
 
 static void _offset(Request& r, const String& method_name, MethodParams *params) {
@@ -230,15 +258,12 @@ static void _offset(Request& r, const St
 				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_to_value(offset_expr).as_int());
-	} else {
-		Value& value=*new(pool) VInt(pool, table.current());
-		value.set_name(method_name);
-		r.write_no_lang(value);
-	}
+	} else
+		r.write_no_lang(*new(pool) VInt(pool, table.current()));
 }
 
 static void _menu(Request& r, const String& method_name, MethodParams *params) {
@@ -246,19 +271,18 @@ 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.self)->table();
 	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_to_value(body_code);
+		StringOrValue 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?
-				r.write_pass_lang(r.process_to_string(*delim_maybe_code));
+				r.write_pass_lang(r.process(*delim_maybe_code));
 			need_delim=true;
 		}
 		r.write_pass_lang(processed_body);
@@ -297,8 +321,8 @@ static void _hash(Request& r, const Stri
 	Pool& pool=r.pool();
 	Table& self_table=static_cast<VTable *>(r.self)->table();
 	Value& result=*new(pool) VHash(pool);
-	if(const Array *columns=self_table.columns()) 
-		if(columns->size()>1) {
+	if(const Array *columns=self_table.columns())
+		if(columns->size()>0) {
 			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);
@@ -328,7 +352,6 @@ static void _hash(Request& r, const Stri
 			Row_info row_info={&self_table, key_field, &value_fields, result.get_hash(0)};
 			self_table.for_each(table_row_to_hash, &row_info);
 		}
-	result.set_name(method_name);
 	r.write_no_lang(result);
 }
 
@@ -410,8 +433,7 @@ static bool _locate_expression(Request&
 
 	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.self)->table();
 	int saved_current=table.current();
 	int size=table.size();
 	for(int row=0; row<size; row++) {
@@ -429,8 +451,7 @@ static bool _locate_name_value(Request&
 			&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.self)->table();
 	return table.locate(
 		params->as_string(0, "column name must be string"),
 		params->as_string(1, "value must be string")
@@ -438,19 +459,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.self)->table();
 	Table& new_table=*new(pool) Table(pool, &method_name, 0/*nameless*/);
 	if(old_table.size())
 		if(int old_cols=old_table.at(0).size()) 
@@ -477,8 +494,7 @@ static void _append(Request& r, const St
 	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.self)->table()+=&row;
 }
 
 static void _join(Request& r, const String& method_name, MethodParams *params) {
@@ -497,9 +513,17 @@ static void _join(Request& r, const Stri
 			&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++) {
@@ -571,7 +595,7 @@ 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_to_value(*vlimit).as_double();
@@ -641,16 +665,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.self)->table();
+	Table& result_table=*new(pool) Table(pool, 
+		source_table.origin_string(), 
+		source_table.columns()
+	);
 
-MTable::MTable(Pool& apool) : Methoded(apool) {
-	set_name(*NEW String(pool(), TABLE_CLASS_NAME));
+	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);
+
+	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]
@@ -698,8 +746,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 +756,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