parser3/src/classes/table.C - diff

Return to table.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/table.C between versions 1.340 and 1.368

version 1.340, 2016/12/26 20:37:53	version 1.368, 2024/10/20 13:29:37
Line 1	Line 1
/** @file	/** @file
Parser: @b table parser class.	Parser: @b table parser class.

Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com)	Copyright (c) 2001-2023 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <paf@design.ru>
*/	*/

	#include "pa_config_includes.h"

	#if (!defined(NO_STRINGSTREAM) && !defined(FREEBSD4) && !defined(PA_DEBUG_DISABLE_GC))
	#include <sstream>
	#include "../lib/gc/include/gc_allocator.h"
	#define USE_STRINGSTREAM
	#endif

#include "classes.h"	#include "classes.h"
#include "pa_vmethod_frame.h"	#include "pa_vmethod_frame.h"

Line 16	Line 24
#include "pa_sql_connection.h"	#include "pa_sql_connection.h"
#include "pa_vbool.h"	#include "pa_vbool.h"
#include "pa_array.h"	#include "pa_array.h"
	#include "pa_varray.h"
#if (!defined(NO_STRINGSTREAM) && !defined(FREEBSD4))
#include <sstream>
#define USE_STRINGSTREAM
#endif

volatile const char * IDENT_TABLE_C="$Id$";	volatile const char * IDENT_TABLE_C="$Id$";

Line 37 public:	Line 41 public:

DECLARE_CLASS_VAR(table, new MTable);	DECLARE_CLASS_VAR(table, new MTable);

#define TABLE_REVERSE_NAME "reverse"

// globals	// globals

String sql_bind_name(SQL_BIND_NAME);	#define TABLE_REVERSE_NAME "reverse"
String sql_limit_name(PA_SQL_LIMIT_NAME);
String sql_offset_name(PA_SQL_OFFSET_NAME);
String sql_default_name(SQL_DEFAULT_NAME);
String sql_distinct_name(SQL_DISTINCT_NAME);
String sql_value_type_name(SQL_VALUE_TYPE_NAME);
String table_reverse_name(TABLE_REVERSE_NAME);	String table_reverse_name(TABLE_REVERSE_NAME);

// methods	// methods
Line 73 static Table::Action_options get_action_	Line 70 static Table::Action_options get_action_
result.offset=source.current();	result.offset=source.current();
else	else
throw Exception(PARSER_RUNTIME, &soffset, "must be 'cur' string or expression");	throw Exception(PARSER_RUNTIME, &soffset, "must be 'cur' string or expression");
} else	} else {
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)) {	if(Value* vlimit=options->get(sql_limit_name)) {
valid_options++;	valid_options++;
result.limit=r.process(*vlimit).as_int();	int limit=r.process(*vlimit).as_int();
	result.limit=limit < 0 ? 0: limit;
}	}
if(Value vreverse=(Value )options->get(table_reverse_name)) {	if(Value vreverse=(Value )options->get(table_reverse_name)) {
valid_options++;	valid_options++;
result.reverse=r.process(*vreverse).as_bool();	result.reverse=r.process(*vreverse).as_bool();
if(result.reverse && !defined_offset)	if(result.reverse && !defined_offset)
result.offset=source.count()-1;	result.offset=source.count()-1;
}	}

if(valid_options!=options->count())	if(valid_options!=options->count())
throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
Line 260 static void _create(Request& r, MethodPa	Line 260 static void _create(Request& r, MethodPa

if(params.count()>1) {	if(params.count()>1) {
if(params[0].is_string()){ // can be nameless only	if(params[0].is_string()){ // can be nameless only
const String& snameless=params.as_string(0, "called with more then 1 param, first param may be only string 'nameless' or junction");	const String& snameless=params.as_string(0, "called with more than 1 param, first param may be only string 'nameless' or junction");
if(snameless!="nameless")	if(snameless!="nameless")
throw Exception(PARSER_RUNTIME, &snameless, "table::create called with more then 1 param, first param may be only 'nameless'");	throw Exception(PARSER_RUNTIME, &snameless, "table::create called with more than 1 param, first param may be only 'nameless'");
nameless=true;	nameless=true;
data_param_index++;	data_param_index++;
}	}
Line 413 static void _load(Request& r, MethodPara	Line 413 static void _load(Request& r, MethodPara

HashStringValue *options=0;	HashStringValue *options=0;
TableControlChars control_chars;	TableControlChars control_chars;
if(options_param_index<params.count()	if(options_param_index<params.count() && (options=params.as_hash(options_param_index)))
&& (options=params.as_hash(options_param_index))) {
// cloning, so that we could change [to simplify checks on params inside file_read_text
options=new HashStringValue(*options);
control_chars.load(*options);	control_chars.load(*options);
}

// loading text	// loading text
char *data=file_load_text(r, r.absolute(params.as_string(filename_param_index, FILE_NAME_MUST_BE_STRING)), true, options);	char *data=file_load_text(r, r.full_disk_path(params.as_string(filename_param_index, FILE_NAME_MUST_BE_STRING)), true, options);

Skip_lines_action skip_lines_action = (control_chars.separator=='#' \|\| control_chars.encloser=='#') ? skip_empty_lines : skip_empty_and_comment_lines;	Skip_lines_action skip_lines_action = (control_chars.separator=='#' \|\| control_chars.encloser=='#') ? skip_empty_lines : skip_empty_and_comment_lines;

Line 465 static void _load(Request& r, MethodPara	Line 461 static void _load(Request& r, MethodPara
}	}

#ifdef USE_STRINGSTREAM	#ifdef USE_STRINGSTREAM
#include "gc_allocator.h"

typedef std::basic_stringstream<char, std::char_traits<char>, gc_allocator<char> > pa_stringstream;	typedef std::basic_stringstream<char, std::char_traits<char>, gc_allocator<char> > pa_stringstream;
typedef std::basic_string<char, std::char_traits<char>, gc_allocator<char> > pa_string;	typedef std::basic_string<char, std::char_traits<char>, gc_allocator<char> > pa_string;
Line 494 static void table_to_csv(pa_stringstream	Line 489 static void table_to_csv(pa_stringstream
if(output_column_names) {	if(output_column_names) {
if(table.columns()) { // named table	if(table.columns()) { // named table
if(control_chars.encloser){	if(control_chars.encloser){
for(Array_iterator<const String> i(table.columns()); i.has_next(); ) {	for(Array_iterator<const String> i(table.columns()); i; ) {
enclose( result, i.next(), control_chars.encloser );	enclose( result, i.next(), control_chars.encloser );
if(i.has_next())	if(i)
result<<control_chars.separator;	result<<control_chars.separator;
}	}
} else {	} else {
for(Array_iterator<const String> i(table.columns()); i.has_next(); ) {	for(Array_iterator<const String> i(table.columns()); i; ) {
result<<i.next()->cstr();	result<<i.next()->cstr();
if(i.has_next())	if(i)
result<<control_chars.separator;	result<<control_chars.separator;
}	}
}	}
Line 527 static void table_to_csv(pa_stringstream	Line 522 static void table_to_csv(pa_stringstream
// process data lines	// process data lines
Array_iterator<ArrayString*> i(table);	Array_iterator<ArrayString*> i(table);
if(control_chars.encloser){	if(control_chars.encloser){
while(i.has_next()) {	while(i) {
for(Array_iterator<const String> c(i.next()); c.has_next(); ) {	for(Array_iterator<const String> c(i.next()); c; ) {
enclose( result, c.next(), control_chars.encloser );	enclose( result, c.next(), control_chars.encloser );
if(c.has_next())	if(c)
result<<control_chars.separator;	result<<control_chars.separator;
}	}
result<<'\n';	result<<'\n';
}	}
} else {	} else {
while(i.has_next()) {	while(i) {
for(Array_iterator<const String> c(i.next()); c.has_next(); ) {	for(Array_iterator<const String> c(i.next()); c; ) {
result<<c.next()->cstr();	result<<c.next()->cstr();
if(c.has_next())	if(c)
result<<control_chars.separator;	result<<control_chars.separator;
}	}
result<<'\n';	result<<'\n';
Line 573 static void table_to_csv(String& result,	Line 568 static void table_to_csv(String& result,
if(output_column_names) {	if(output_column_names) {
if(table.columns()) { // named table	if(table.columns()) { // named table
if(control_chars.encloser) {	if(control_chars.encloser) {
for(Array_iterator<const String> i(table.columns()); i.has_next(); ) {	for(Array_iterator<const String> i(table.columns()); i; ) {
enclose( result, i.next(), control_chars.encloser, control_chars.sencloser );	enclose( result, i.next(), control_chars.encloser, control_chars.sencloser );
if(i.has_next())	if(i)
result<<*control_chars.sseparator;	result<<*control_chars.sseparator;
}	}
} else {	} else {
for(Array_iterator<const String> i(table.columns()); i.has_next(); ) {	for(Array_iterator<const String> i(table.columns()); i; ) {
result<<*i.next();	result<<*i.next();
if(i.has_next())	if(i)
result<<*control_chars.sseparator;	result<<*control_chars.sseparator;
}	}
}	}
Line 589 static void table_to_csv(String& result,	Line 584 static void table_to_csv(String& result,
if(int lsize=table.count()?table[0]->count():0)	if(int lsize=table.count()?table[0]->count():0)
for(int column=0; column<lsize; column++) {	for(int column=0; column<lsize; column++) {
if(control_chars.encloser) {	if(control_chars.encloser) {
result<<control_chars.sencloser<<String::Body::Format(column)<<control_chars.sencloser;	result<<control_chars.sencloser<<pa_uitoa(column)<<control_chars.sencloser;
} else {	} else {
result<<String::Body::Format(column);	result<<pa_uitoa(column);
}	}
if(column<lsize-1){	if(column<lsize-1){
result<<*control_chars.sseparator;	result<<*control_chars.sseparator;
Line 606 static void table_to_csv(String& result,	Line 601 static void table_to_csv(String& result,
// data lines	// data lines
Array_iterator<ArrayString*> i(table);	Array_iterator<ArrayString*> i(table);
if(control_chars.encloser){	if(control_chars.encloser){
while(i.has_next()) {	while(i) {
for(Array_iterator<const String> c(i.next()); c.has_next(); ) {	for(Array_iterator<const String> c(i.next()); c; ) {
enclose( result, c.next(), control_chars.encloser, control_chars.sencloser );	enclose( result, c.next(), control_chars.encloser, control_chars.sencloser );
if(c.has_next())	if(c)
result<<*control_chars.sseparator;	result<<*control_chars.sseparator;
}	}
result.append_know_length("\n", 1, String::L_CLEAN);	result.append_know_length("\n", 1, String::L_CLEAN);
}	}
} else {	} else {
while(i.has_next()) {	while(i) {
for(Array_iterator<const String> c(i.next()); c.has_next(); ) {	for(Array_iterator<const String> c(i.next()); c; ) {
result<<*c.next();	result<<*c.next();
if(c.has_next())	if(c)
result<<*control_chars.sseparator;	result<<*control_chars.sseparator;
}	}
result.append_know_length("\n", 1, String::L_CLEAN);	result.append_know_length("\n", 1, String::L_CLEAN);
Line 644 static void _save(Request& r, MethodPara	Line 639 static void _save(Request& r, MethodPara
--param_index;	--param_index;

const String& file_name=params.as_string(param_index++, FILE_NAME_MUST_NOT_BE_CODE);	const String& file_name=params.as_string(param_index++, FILE_NAME_MUST_NOT_BE_CODE);
String file_spec=r.absolute(file_name);	String file_spec=r.full_disk_path(file_name);

if(do_append && file_exist(file_spec))	if(do_append && file_exist(file_spec))
output_column_names=false;	output_column_names=false;
Line 781 static void _menu(Request& r, MethodPara	Line 776 static void _menu(Request& r, MethodPara
table.set_current(row);	table.set_current(row);

Value& sv_processed=r.process(body_code);	Value& sv_processed=r.process(body_code);
Request::Skip lskip=r.get_skip(); r.set_skip(Request::SKIP_NOTHING);	TempSkip4Delimiter skip(r);

const String* s_processed=sv_processed.get_string();	const String* s_processed=sv_processed.get_string();
if(s_processed && !s_processed->is_empty()) { // we have body	if(s_processed && !s_processed->is_empty()) { // we have body
Line 793 static void _menu(Request& r, MethodPara	Line 788 static void _menu(Request& r, MethodPara

r.write(sv_processed);	r.write(sv_processed);

if(lskip==Request::SKIP_BREAK)	if(skip.check_break())
break;	break;
}	}
} else {	} else {
Line 801 static void _menu(Request& r, MethodPara	Line 796 static void _menu(Request& r, MethodPara
table.set_current(row);	table.set_current(row);

r.process_write(body_code);	r.process_write(body_code);
Request::Skip lskip=r.get_skip(); r.set_skip(Request::SKIP_NOTHING);

if(lskip==Request::SKIP_BREAK)	if(r.check_skip_break())
break;	break;
}	}
}	}
Line 831 static void table_row_to_hash(Table::ele	Line 825 static void table_row_to_hash(Table::ele
Value& sv_processed=info->r->process(*info->key_code);	Value& sv_processed=info->r->process(*info->key_code);
key=&sv_processed.as_string();	key=&sv_processed.as_string();
} else {	} else {
key=info->key_field<row->count()?row->get(info->key_field):0;	key=info->key_field < row->count() ? row->get(info->key_field) : 0;
}	}

if(!key)	if(!key)
Line 851 static void table_row_to_hash(Table::ele	Line 845 static void table_row_to_hash(Table::ele
case C_HASH: {	case C_HASH: {
VHash* vhash=new VHash;	VHash* vhash=new VHash;
HashStringValue& hash=vhash->hash();	HashStringValue& hash=vhash->hash();
for(Array_iterator<int> i(*info->value_fields); i.has_next(); ) {	Table::columns_type columns=info->table->columns();
size_t value_field=i.next();	if(info->value_fields){ // selected fields (can be empty)
if(value_field<row->count())	for(Array_iterator<int> i(*info->value_fields); i; ) {
hash.put(info->table->columns()->get(value_field), new VString(row->get(value_field)));	size_t value_field=i.next();
	if(value_field<row->count())
	hash.put(columns ? columns->get(value_field) : String(pa_uitoa(value_field)), new VString(row->get(value_field)));
	}
	} else { // all fields
	for(size_t index=0; index<row->count(); index++) {
	hash.put(columns && index < columns->count() ? columns->get(index) : String(pa_uitoa(index)), new VString(row->get(index)));
	}
}	}

exist=info->hash->put_dont_replace(*key, vhash);	exist=info->hash->put_dont_replace(*key, vhash);
break;	break;
}	}
Line 922 static Table2hash_distint get_distinct(V	Line 922 static Table2hash_distint get_distinct(V
static void _hash(Request& r, MethodParams& params) {	static void _hash(Request& r, MethodParams& params) {
Table& self_table=GET_SELF(r, VTable).table();	Table& self_table=GET_SELF(r, VTable).table();
VHash& result=*new VHash;	VHash& result=*new VHash;
if(Table::columns_type columns=self_table.columns()){
if(columns->count()>0) {
Table2hash_distint distinct=D_ILLEGAL;
Table2hash_value_type value_type=C_HASH;
int param_index=params.count()-1;
if(param_index>0) {

if(params[1].get_junction())
value_type=C_CODE;

if(HashStringValue* options=params[param_index].get_hash()){ // can't use .as_hash because the 2nd param could be table so .as_hash throws an error
--param_index;
int valid_options=0;
if(Value* vdistinct_code=options->get(sql_distinct_name)) { // $.distinct ?
valid_options++;
distinct=get_distinct(r.process(*vdistinct_code), value_type);
}
if(Value* vvalue_type_code=options->get(sql_value_type_name)) { // $.type ?
if(value_type==C_TABLE) // $.distinct[tables] already was specified
throw Exception(PARSER_RUNTIME, 0, "you can't specify $.distinct[tables] and $.type[] together");
if(value_type==C_CODE)
throw Exception(PARSER_RUNTIME, 0, "you can't specify $.type[] if value is code");
valid_options++;
value_type=get_value_type(r.process(*vvalue_type_code));
}

if(valid_options!=options->count())	Table2hash_distint distinct=D_ILLEGAL;
throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);	Table2hash_value_type value_type=C_HASH;
}
	int param_index=params.count()-1;
	if(param_index>0) {
	if(params[1].get_junction())
	value_type=C_CODE;

	if(HashStringValue* options=params[param_index].get_hash()){ // can't use .as_hash because the 2nd param could be table so .as_hash throws an error
	--param_index;
	int valid_options=0;
	if(Value* vdistinct_code=options->get(sql_distinct_name)) { // $.distinct ?
	valid_options++;
	distinct=get_distinct(r.process(*vdistinct_code), value_type);
	}
	if(Value* vvalue_type_code=options->get(sql_value_type_name)) { // $.type ?
	if(value_type==C_TABLE) // $.distinct[tables] already was specified
	throw Exception(PARSER_RUNTIME, 0, "you can't specify $.distinct[tables] and $.type[] together");
	if(value_type==C_CODE)
	throw Exception(PARSER_RUNTIME, 0, "you can't specify $.type[] if value is code");
	valid_options++;
	value_type=get_value_type(r.process(*vvalue_type_code));
}	}

if(param_index==2) // options were specified but not as hash	if(valid_options!=options->count())
throw Exception(PARSER_RUNTIME, 0, "options must be hash");	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
	}
	}

Array<int> value_fields;	if(param_index==2) // options were specified but not as hash
Value* value_code=0;	throw Exception(PARSER_RUNTIME, 0, "options must be hash");

if(param_index==0){ // list of columns wasn't specified	bool value_all=false;
if(value_type==C_STRING) // $.type[string]	Array<int> value_fields;
throw Exception(PARSER_RUNTIME, 0, "you must specify one value field with option $.type[string]");	Value* value_code=0;

for(size_t i=0; i<columns->count(); i++) // by all columns, including key	if(param_index==0){ // list of columns wasn't specified
value_fields+=i;	if(value_type==C_STRING)
	throw Exception(PARSER_RUNTIME, 0, "you must specify one value field with option $.type[string]");
} else { // list of columns or code was specified
if(value_type==C_TABLE)	value_all=true; // all columns, including key
throw Exception(PARSER_RUNTIME, 0, "you can't specify value field(s) with option $.distinct[tables] or $.type[tables]");	} else { // list of columns or code was specified
	if(value_type==C_TABLE)
Value& value_fields_param=params[1];	throw Exception(PARSER_RUNTIME, 0, "you can't specify value field(s) with option $.distinct[tables] or $.type[tables]");
if(value_fields_param.get_junction()){ // code specified
value_code=&value_fields_param;	Value& value_fields_param=params[1];
} else if(value_fields_param.is_string()) { // one column as string was specified	if(value_fields_param.get_junction()){ // code specified
const String &field_name=*value_fields_param.get_string();	value_code=&value_fields_param;
if(!field_name.is_empty())	} else if(value_fields_param.is_string()) { // one column as string was specified
value_fields+=self_table.column_name2index(field_name, true);	const String &field_name=*value_fields_param.get_string();
} else if(Table* value_fields_table=value_fields_param.get_table()) { // list of columns were specified in table	if(!field_name.is_empty())
for(Array_iterator<Table::element_type> i(*value_fields_table); i.has_next(); ) {	value_fields+=self_table.column_name2index(field_name, true);
const String& value_field_name =*i.next()->get(0);	} else if(Table* value_fields_table=value_fields_param.get_table()) { // list of columns were specified in table
value_fields +=self_table.column_name2index(value_field_name, true);	for(Array_iterator<Table::element_type> i(*value_fields_table); i; ) {
}	const String& value_field_name =*i.next()->get(0);
} else	value_fields +=self_table.column_name2index(value_field_name, true);
throw Exception(PARSER_RUNTIME, 0, "value field(s) must be string or table or code");
}	}
	} else
	throw Exception(PARSER_RUNTIME, 0, "value field(s) must be string or table or code");

if(value_type==C_STRING && value_fields.count()>1)	if(value_type==C_STRING && value_fields.count()>1)
throw Exception(PARSER_RUNTIME, 0, "you can't specify more then one value field with option $.type[string]");	throw Exception(PARSER_RUNTIME, 0, "you can't specify more than one value field with option $.type[string]");
	}

{	Value* key_param=&params[0];
Value* key_param=&params[0];	Row_info info={
Row_info info={	&r,
&r,	&self_table,
&self_table,	/key_code=/key_param->get_junction() ? key_param : 0,
/key_code=/key_param->get_junction() ? key_param : 0,	/key_field=/0/filled below/,
/key_field=/0/filled below/,	value_all ? NULL : &value_fields,
&value_fields,	value_code,
value_code,	&result.hash(),
&result.hash(),	distinct,
distinct,	/row=/0,
/row=/0,	value_type
value_type	};
};	info.key_field=(info.key_code ? -1 : self_table.column_name2index(key_param->as_string(), true));
info.key_field=(info.key_code ? -1 : self_table.column_name2index(key_param->as_string(), true));
	int saved_current=self_table.current();
int saved_current=self_table.current();	self_table.for_each(table_row_to_hash, &info);
self_table.for_each(table_row_to_hash, &info);	self_table.set_current(saved_current);
self_table.set_current(saved_current);

result.extract_default();	result.extract_default();
}
}	r.write(result);
	}

	static void _cells(Request& r, MethodParams& params) {
	Table& self_table=GET_SELF(r, VTable).table();
	size_t row_size=self_table[self_table.current()]->count(); // number of columns in current row

	if(params.count()){
	int limit=params.as_int(params.count()-1, "offset must be expression", r);
	if(limit<0)
	limit=0;
	if((size_t)limit<row_size)
	row_size=limit;
	}

	VArray& result=*new VArray(row_size);
	ArrayValue& result_array=result.array();

	for(size_t index=0; index<row_size; index++){
	const String* column_item=self_table.item(index);
	result_array+=column_item ? new VString(*column_item) : VString::empty();
}	}
r.write(result);	r.write(result);
}	}

#ifndef DOXYGEN	#ifndef DOXYGEN
struct Table_seq_item {	struct Table_seq_item : public PA_Allocated {
ArrayString* row;	ArrayString* row;
union {	union {
const char *c_str;	const char *c_str;
Line 1049 static void _sort(Request& r, MethodPara	Line 1066 static void _sort(Request& r, MethodPara
Table& old_table=GET_SELF(r, VTable).table();	Table& old_table=GET_SELF(r, VTable).table();
Table& new_table=*new Table(old_table.columns());	Table& new_table=*new Table(old_table.columns());

Table_seq_item* seq=new(PointerFreeGC) Table_seq_item[old_table.count()];	Table_seq_item* seq=new Table_seq_item[old_table.count()];
int i;	int i;

// calculate key values	// calculate key values
Line 1167 static void _foreach(Request& r, MethodP	Line 1184 static void _foreach(Request& r, MethodP
table.set_current(row);	table.set_current(row);

if(rownum_var_name)	if(rownum_var_name)
r.put_element(var_context, rownum_var_name, new VString(*new String(String::Body::Format(row), String::L_CLEAN)));	r.put_element(var_context, rownum_var_name, new VString(*new String(pa_uitoa(row), String::L_CLEAN)));
if(value_var_name)	if(value_var_name)
r.put_element(var_context, value_var_name, new VTable(&table));	r.put_element(var_context, value_var_name, new VTable(&table));

Value& sv_processed=r.process(body_code);	Value& sv_processed=r.process(body_code);
Request::Skip lskip=r.get_skip(); r.set_skip(Request::SKIP_NOTHING);	TempSkip4Delimiter skip(r);

const String* s_processed=sv_processed.get_string();	const String* s_processed=sv_processed.get_string();
if(s_processed && !s_processed->is_empty()) { // we have body	if(s_processed && !s_processed->is_empty()) { // we have body
Line 1184 static void _foreach(Request& r, MethodP	Line 1201 static void _foreach(Request& r, MethodP

r.write(sv_processed);	r.write(sv_processed);

if(lskip==Request::SKIP_BREAK)	if(skip.check_break())
break;	break;
}	}
} else {	} else {
Line 1192 static void _foreach(Request& r, MethodP	Line 1209 static void _foreach(Request& r, MethodP
table.set_current(row);	table.set_current(row);

if(rownum_var_name)	if(rownum_var_name)
r.put_element(var_context, rownum_var_name, new VString(*new String(String::Body::Format(row), String::L_CLEAN)));	r.put_element(var_context, rownum_var_name, new VString(*new String(pa_uitoa(row), String::L_CLEAN)));
if(value_var_name)	if(value_var_name)
r.put_element(var_context, value_var_name, new VTable(&table));	r.put_element(var_context, value_var_name, new VTable(&table));

r.process_write(body_code);	r.process_write(body_code);
Request::Skip lskip=r.get_skip(); r.set_skip(Request::SKIP_NOTHING);

if(lskip==Request::SKIP_BREAK)	if(r.check_skip_break())
break;	break;
}	}
}	}
Line 1270 static void join_nameless_row(Table& src	Line 1286 static void join_nameless_row(Table& src
*dest+=src[src.current()];	*dest+=src[src.current()];
}	}
static void _join(Request& r, MethodParams& params) {	static void _join(Request& r, MethodParams& params) {
Table& src=*params.as_table(0, "source");	if(Table* src=params.as_table(0, "source")){
	Table::Action_options o=get_action_options(r, params, 1, *src);
Table::Action_options o=get_action_options(r, params, 1, src);

Table& dest=GET_SELF(r, VTable).table();	Table& dest=GET_SELF(r, VTable).table();
if(&src == &dest)	if(src == &dest)
throw Exception(PARSER_RUNTIME, 0, "source and destination are same table");	throw Exception(PARSER_RUNTIME, 0, "source and destination are same table");

if(dest.columns()) // dest is named	if(dest.columns()) // dest is named
src.table_for_each(join_named_row, &dest, o);	src->table_for_each(join_named_row, &dest, o);
else // dest is nameless	else // dest is nameless
src.table_for_each(join_nameless_row, &dest, o);	src->table_for_each(join_nameless_row, &dest, o);
	}
}	}

#ifndef DOXYGEN	#ifndef DOXYGEN
Line 1301 public:	Line 1317 public:
columns+=new String(str, String::L_TAINTED /* no length as 0x00 can be inside */);	columns+=new String(str, String::L_TAINTED /* no length as 0x00 can be inside */);
return false;	return false;
} catch(...) {	} catch(...) {
error=SQL_Error("exception occured in Table_sql_event_handlers::add_column");	error=SQL_Error("exception occurred in Table_sql_event_handlers::add_column");
return true;	return true;
}	}
}	}
bool before_rows(SQL_Error& error) {	bool before_rows(SQL_Error& error) {
	if(table) {
	error=SQL_Error("result must contain exactly one table");
	return true;
	}
try {	try {
table=new Table(&columns);	table=new Table(&columns);
columns_count=columns.count();	columns_count=columns.count();
return false;	return false;
} catch(...) {	} catch(...) {
error=SQL_Error("exception occured in Table_sql_event_handlers::before_rows");	error=SQL_Error("exception occurred in Table_sql_event_handlers::before_rows");
return true;	return true;
}	}
}	}
Line 1320 public:	Line 1340 public:
*table+=row=new ArrayString(columns_count);	*table+=row=new ArrayString(columns_count);
return false;	return false;
} catch(...) {	} catch(...) {
error=SQL_Error("exception occured in Table_sql_event_handlers::add_row");	error=SQL_Error("exception occurred in Table_sql_event_handlers::add_row");
return true;	return true;
}	}
}	}
Line 1329 public:	Line 1349 public:
row+=str?new String(str, String::L_TAINTED / no length as 0x00 can be inside */):&String::Empty;	row+=str?new String(str, String::L_TAINTED / no length as 0x00 can be inside */):&String::Empty;
return false;	return false;
} catch(...) {	} catch(...) {
error=SQL_Error("exception occured in Table_sql_event_handlers::add_row_cell");	error=SQL_Error("exception occurred in Table_sql_event_handlers::add_row_cell");
return true;	return true;
}	}
}	}
};	};
#endif	#endif

static void marshal_bind(	static void marshal_bind( HashStringValue::key_type aname, HashStringValue::value_type avalue, SQL_Driver::Placeholder** pptr) {
HashStringValue::key_type aname,
HashStringValue::value_type avalue,
SQL_Driver::Placeholder** pptr)
{
SQL_Driver::Placeholder& ph=**pptr;	SQL_Driver::Placeholder& ph=**pptr;
ph.name=aname.cstr();	ph.name=aname.cstr();
ph.value=avalue->as_string().untaint_cstr(String::L_AS_IS);	ph.value=avalue->as_string().untaint_cstr(String::L_AS_IS);
Line 1353 static void marshal_bind(	Line 1369 static void marshal_bind(
// not static, used elsewhere	// not static, used elsewhere
int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders) {	int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders) {
int hash_count=hash.count();	int hash_count=hash.count();
placeholders=new SQL_Driver::Placeholder[hash_count];	placeholders=new(PointerGC) SQL_Driver::Placeholder[hash_count];
SQL_Driver::Placeholder* ptr=placeholders;	SQL_Driver::Placeholder* ptr=placeholders;
hash.for_each<SQL_Driver::Placeholder**>(marshal_bind, &ptr);	hash.for_each<SQL_Driver::Placeholder**>(marshal_bind, &ptr);
return hash_count;	return hash_count;
Line 1439 static void _columns(Request& r, MethodP	Line 1455 static void _columns(Request& r, MethodP

Table& source_table=GET_SELF(r, VTable).table();	Table& source_table=GET_SELF(r, VTable).table();
if(Table::columns_type source_columns=source_table.columns()) {	if(Table::columns_type source_columns=source_table.columns()) {
for(Array_iterator<const String> i(source_columns); i.has_next(); ) {	for(Array_iterator<const String> i(source_columns); i; ) {
Table::element_type result_row(new ArrayString);	Table::element_type result_row(new ArrayString);
*result_row+=i.next();	*result_row+=i.next();
result_table+=result_row;	result_table+=result_row;
Line 1450 static void _columns(Request& r, MethodP	Line 1466 static void _columns(Request& r, MethodP
}	}

static void _select(Request& r, MethodParams& params) {	static void _select(Request& r, MethodParams& params) {
	InCycle temp(r);
Value& vcondition=params.as_expression(0, "condition must be number, bool or expression");	Value& vcondition=params.as_expression(0, "condition must be number, bool or expression");

Table& source_table=GET_SELF(r, VTable).table();	Table& source_table=GET_SELF(r, VTable).table();
Line 1492 static void _select(Request& r, MethodPa	Line 1509 static void _select(Request& r, MethodPa

bool condition=r.process(vcondition).as_bool();	bool condition=r.process(vcondition).as_bool();

	if(r.check_skip_break())
	break;

if(condition && ++appended > (size_t)offset) // ...condition is true, adding to the result	if(condition && ++appended > (size_t)offset) // ...condition is true, adding to the result
result_table+=source_table[row];	result_table+=source_table[row];
if(row==0) break;	if(row==0) break;
Line 1502 static void _select(Request& r, MethodPa	Line 1522 static void _select(Request& r, MethodPa

bool condition=r.process(vcondition).as_bool();	bool condition=r.process(vcondition).as_bool();

	if(r.check_skip_break())
	break;

if(condition && ++appended > (size_t)offset) // ...condition is true, adding to the result	if(condition && ++appended > (size_t)offset) // ...condition is true, adding to the result
result_table+=source_table[row];	result_table+=source_table[row];
}	}
Line 1512 static void _select(Request& r, MethodPa	Line 1535 static void _select(Request& r, MethodPa
r.write(*new VTable(&result_table));	r.write(*new VTable(&result_table));
}	}


	static void _rename(Request& r, MethodParams& params) {
	const String* name_from=NULL;
	const String* name_to=NULL;
	HashStringValue* names=NULL;

	if(params.count()>1){
	name_from=&params.as_string(0, COLUMN_NAME_MUST_BE_STRING);
	name_to=&params.as_string(1, COLUMN_NAME_MUST_BE_STRING);
	} else
	names=params.as_hash(0);

	Table& table=GET_SELF(r, VTable).table();
	if(Table::columns_type columns=table.columns()) {
	if(names){
	for(size_t i=0; i<columns->count(); i++) {
	const String *column = columns->get(i);
	if(Value* vto=names->get(*column)){
	if(const String *sto=vto->get_string())
	columns->put(i, sto);
	else
	throw Exception(PARSER_RUNTIME, column, COLUMN_NAME_MUST_BE_STRING);
	}
	}
	} else if(name_from){
	for(size_t i=0; i<columns->count(); i++) {
	const String *column = columns->get(i);
	if(column == name_from)
	columns->put(i, name_to);
	}
	}
	table.column_names_init();
	} else
	throw Exception(PARSER_RUNTIME, 0, "columns renaming is not supported for nameless tables");
	}

// constructor	// constructor

MTable::MTable(): Methoded("table") {	MTable::MTable(): Methoded("table") {
Line 1559 MTable::MTable(): Methoded("table") {	Line 1618 MTable::MTable(): Methoded("table") {
// ^table.hash[key field name][value field name(s) string/table]	// ^table.hash[key field name][value field name(s) string/table]
add_native_method("hash", Method::CT_DYNAMIC, _hash, 1, 3);	add_native_method("hash", Method::CT_DYNAMIC, _hash, 1, 3);

	// ^table.cells[]
	// ^table.cells(limit)
	add_native_method("cells", Method::CT_DYNAMIC, _cells, 0, 1);

// ^table.sort{string-key-maker} ^table.sort{string-key-maker}[desc\|asc]	// ^table.sort{string-key-maker} ^table.sort{string-key-maker}[desc\|asc]
// ^table.sort(numeric-key-maker) ^table.sort(numeric-key-maker)[desc\|asc]	// ^table.sort(numeric-key-maker) ^table.sort(numeric-key-maker)[desc\|asc]
add_native_method("sort", Method::CT_DYNAMIC, _sort, 1, 2);	add_native_method("sort", Method::CT_DYNAMIC, _sort, 1, 2);
Line 1595 MTable::MTable(): Methoded("table") {	Line 1658 MTable::MTable(): Methoded("table") {

// ^table.select(expression) = table	// ^table.select(expression) = table
add_native_method("select", Method::CT_DYNAMIC, _select, 1, 2);	add_native_method("select", Method::CT_DYNAMIC, _select, 1, 2);

	// ^table.rename[column name from;column name to]
	// ^table.rename[ $.[column name from][column name to] ... ]
	add_native_method("rename", Method::CT_DYNAMIC, _rename, 1, 2);
}	}

E-mail:

Removed from v.1.340
changed lines
	Added in v.1.368