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.307 and 1.371

version 1.307, 2015/07/28 21:23:38	version 1.371, 2024/11/13 17:37:41
Line 1	Line 1
/** @file	/** @file
Parser: @b table parser class.	Parser: @b table parser class.

Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)	Copyright (c) 2001-2024 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 35 public:	Line 39 public:

// global variable	// global variable

DECLARE_CLASS_VAR(table, new MTable, 0);	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

static Table::Action_options get_action_options(Request& r, MethodParams& params,	static Table::Action_options get_action_options(Request& r, MethodParams& params, size_t options_index, const Table& source) {
size_t options_index, const Table& source) {
Table::Action_options result;	Table::Action_options result;
if(params.count() <= options_index)	if(params.count() <= options_index)
return result;	return result;
Line 73 static Table::Action_options get_action_	Line 69 static Table::Action_options get_action_
if(soffset == "cur")	if(soffset == "cur")
result.offset=source.current();	result.offset=source.current();
else	else
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, &soffset, "must be 'cur' string or expression");
&soffset,	} else {
"must be 'cur' string or expression");	int offset=r.process(*voffset).as_int();
} else	result.offset=offset < 0 ? 0 : offset;
result.offset=r.process_to_value(*voffset).as_int();	}
}	}
if(Value* vlimit=options->get(sql_limit_name)) {	if(Value* vlimit=options->get(sql_limit_name)) {
valid_options++;	valid_options++;
result.limit=r.process_to_value(*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_to_value(*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 96 static Table::Action_options get_action_	Line 93 static Table::Action_options get_action_
return result;	return result;
}	}

struct TableSeparators {	struct TableControlChars {
char column; const String* scolumn;	char separator; const String* sseparator;
char encloser; const String* sencloser;	char encloser; const String* sencloser;

TableSeparators():	char separators[3];
column('\t'), scolumn(new String("\t")),
	TableControlChars():
	separator('\t'), sseparator(new String("\t")),
encloser(0), sencloser(0)	encloser(0), sencloser(0)
{}	{
	strcpy(separators,"\t\n");
	}

int load( HashStringValue& options ) {	int load( HashStringValue& options ) {
int result=0;	int result=0;
if(Value* vseparator=options.get(PA_COLUMN_SEPARATOR_NAME)) {	if(Value* vseparator=options.get(PA_COLUMN_SEPARATOR_NAME)) {
scolumn=&vseparator->as_string();	sseparator=&vseparator->as_string();
if(scolumn->length()!=1)	if(sseparator->length()!=1)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, sseparator, "separator must be one byte character");
scolumn,	separator=sseparator->first_char();
"separator must be one character long");	separators[0]=separator;
column=scolumn->first_char();
result++;	result++;
}	}
if(Value* vencloser=options.get(PA_COLUMN_ENCLOSER_NAME)) {	if(Value* vencloser=options.get(PA_COLUMN_ENCLOSER_NAME)) {
Line 120 struct TableSeparators {	Line 121 struct TableSeparators {
if(sencloser->is_empty()){	if(sencloser->is_empty()){
encloser=0;	encloser=0;
} else {	} else {
if(sencloser->length()!=1)	if(sencloser->length()!=1)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, sencloser, "encloser must be empty or one byte character");
sencloser,	encloser=sencloser->first_char();
"encloser must be one character long");
encloser=sencloser->first_char();
}	}
result++;	result++;
}	}
Line 132 struct TableSeparators {	Line 131 struct TableSeparators {
}	}
};	};


	struct lsplit_sresult {
	String* piece;
	char delim;

	lsplit_sresult() : piece(0), delim(0){}

	operator bool() { return piece!=0; }

	void append(String *str){
	if(piece)
	piece << str;
	else
	piece = str;
	}
	};

	class StringSplitHelper : public String {
	public:
	char* base;

	StringSplitHelper(String astring) : String(astring), base(cstrm()) {}

	bool check_lang(const char *pos){
	return langs.check_lang(L_AS_IS, pos-base, 1);
	}

	String extract(char pos){
	String *result=new String;
	if(size_t len=strlen(pos)){
	// first: their langs
	result->langs.append(result->body, langs, pos-base, len);
	// next: letters themselves
	result->body=Body(pos);
	}
	return result;
	}
	};

	inline lsplit_sresult lsplit(char* string_ref, const char delims, StringSplitHelper& helper) {
	lsplit_sresult result;
	if(char pos=string_ref) {
	while(pos=strpbrk(pos, delims)) {
	if(helper.check_lang(pos)){
	result.delim=*pos;
	*pos=0;
	result.piece=helper.extract(*string_ref);
	*string_ref=pos+1;
	return result;
	}
	pos++;
	}
	result.piece=helper.extract(*string_ref);
	*string_ref=0;
	}
	return result;
	}

	static lsplit_sresult lsplit(char** string_ref, const char* delims, char encloser, StringSplitHelper& helper) {
	lsplit_sresult result;

	if(char pos=string_ref) {
	if(encloser && *pos==encloser && helper.check_lang(pos)) {
	*string_ref=++pos;

	// we are enclosed, searching for second encloser
	while(1) {
	if(pos=strchr(pos, encloser)){
	if(helper.check_lang(pos)){
	*(pos++)=0;
	result.append(helper.extract(*string_ref));
	if(*pos==encloser && helper.check_lang(pos)){ // double-encloser stands for encloser
	*string_ref=pos;
	} else {
	*string_ref=pos;
	break;
	}
	}
	pos++;
	} else {
	result.append(helper.extract(*string_ref));
	*string_ref=0;
	return result;
	}
	}

	// we are no longer enclosed, searching for delimiter
	while(pos=strpbrk(pos, delims)) {
	if(helper.check_lang(pos)){
	result.delim=*pos;
	if(pos>*string_ref){
	*pos=0;
	result.append(helper.extract(*string_ref));
	}
	*string_ref=pos+1;
	return result;
	}
	pos++;
	}
	result.append(helper.extract(*string_ref));
	*string_ref=0;
	} else
	return lsplit(string_ref, delims, helper);
	}
	return result;
	}

	static void skip_clean_empty_lines(char** data_ref, StringSplitHelper& helper) {
	if(*data_ref) {
	while(*data_ref == '\n' && helper.check_lang(data_ref))
	(*data_ref)++;
	}
	}

static void _create(Request& r, MethodParams& params) {	static void _create(Request& r, MethodParams& params) {
// clone/copy part?	// clone/copy part?
if(Table *source=params[0].get_table()) {	if(Table *source=params[0].get_table()) {
Line 147 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,	throw Exception(PARSER_RUNTIME, &snameless, "table::create called with more than 1 param, first param may be only 'nameless'");
&snameless,
"table::create called with more then 1 param, first param may be only 'nameless'");
nameless=true;	nameless=true;
data_param_index++;	data_param_index++;
}	}
}	}

HashStringValue *options=0;	HashStringValue *options=0;
TableSeparators separators;	TableControlChars control_chars;

size_t options_param_index=data_param_index+1;	size_t options_param_index=data_param_index+1;
if(	if( options_param_index<params.count() && (options=params.as_hash(options_param_index)) ) {
options_param_index<params.count()	if(control_chars.load(*options)!=options->count())
&& (options=params.as_hash(options_param_index))	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
) {
// cloning, so that we could change
options=new HashStringValue(*options);
separators.load(*options);
if(separators.encloser){
throw Exception(PARSER_RUNTIME,
0,
"encloser not supported for table::create yet");
}
}	}

// data	// data
Temp_lang temp_lang(r, String::L_PASS_APPENDED);	StringSplitHelper sdata(r.process_to_string(params.as_junction(data_param_index, "body must be table or code")));
const String& data=	char *data=sdata.base;
r.process_to_string(params.as_junction(data_param_index, "body must be table or code"));

// parse columns	// parse columns
size_t raw_pos_after=0;
Table::columns_type columns;	Table::columns_type columns;
	if(nameless) {
if(nameless){	columns=0; // nameless
columns=Table::columns_type(0); // nameless
} else {	} else {
columns=Table::columns_type(new ArrayString);	columns=new ArrayString;
	while( lsplit_sresult sr=lsplit(&data, control_chars.separators, control_chars.encloser, sdata) ) {
ArrayString head;	*columns+=sr.piece;
data.split(head, raw_pos_after, "\n", String::L_AS_IS, 1);	if(sr.delim=='\n')
if(head.count()) {	break;
size_t col_pos_after=0;
if(head[0]->is_empty())
*columns += new String();
else
head[0]->split(columns, col_pos_after, separators.scolumn, String::L_AS_IS);
}	}
}	}

Table& table=*new Table(columns);	Table& table=*new Table(columns);
// parse cells	int columns_count=columns ? columns->count(): 0;

ArrayString rows;	// parse cells
data.split(rows, raw_pos_after, "\n", String::L_AS_IS);	Table::element_type row(new ArrayString(columns_count));
Array_iterator<const String*> i(rows);	skip_clean_empty_lines(&data, sdata);
while(i.has_next()) {	while( lsplit_sresult sr=lsplit(&data, control_chars.separators, control_chars.encloser, sdata) ) {
Table::element_type row(new ArrayString);	if(sr.piece->is_empty() && !sr.delim && !row->count()) // append last empty column [if without \n]
const String& string=*i.next();	break;
// remove comment lines	*row+=sr.piece;
if(string.is_empty())	if(sr.delim=='\n') {
continue;	table+=row;
	row=new ArrayString(columns_count);
size_t col_pos_after=0;	skip_clean_empty_lines(&data, sdata);
string.split(row, col_pos_after, separators.scolumn, String::L_AS_IS);	}
table+=row;
}	}
	// last line [if without \n]
	if(row->count())
	table+=row;

// replace any previous table value	// replace any previous table value
GET_SELF(r, VTable).set_table(table);	GET_SELF(r, VTable).set_table(table);
}	}
Line 226 struct lsplit_result {	Line 322 struct lsplit_result {
char* piece;	char* piece;
char delim;	char delim;

	lsplit_result(char *apiece=0) : piece(apiece), delim(0){}
operator bool() { return piece!=0; }	operator bool() { return piece!=0; }
};	};

inline lsplit_result lsplit(char* string, char delim1, char delim2) {	inline lsplit_result lsplit(char* string_ref, const char delims) {
lsplit_result result;	lsplit_result result(*string_ref);
if(string) {	if(result.piece) {
char delims[]={delim1, delim2, 0};	if(char* v=strpbrk(result.piece, delims)) {
if(char* v=strpbrk(string, delims)) {
result.delim=*v;	result.delim=*v;
*v=0;	*v=0;
result.piece=v+1;	*string_ref=v+1;
return result;	return result;
}	}
	*string_ref=0;
}	}
result.piece=0;
result.delim=0;
return result;	return result;
}	}

inline lsplit_result lsplit(char* *string_ref, char delim1, char delim2) {	static lsplit_result lsplit(char** string_ref, const char* delims, char encloser) {
lsplit_result result;	lsplit_result result(*string_ref);
result.piece=*string_ref;
lsplit_result next=lsplit(*string_ref, delim1, delim2);
result.delim=next.delim;
*string_ref=next.piece;
return result;
}

static lsplit_result lsplit(char** string_ref, char delim1, char delim2, char encloser) {
lsplit_result result;

if(char* string=*string_ref) {	if(result.piece) {
if(encloser && *string==encloser) {	if(encloser && *result.piece==encloser) {
string++;	result.piece++;

	char c;
char *read;	char *read;
char *write;	char *write;
write=read=string;	write=read=result.piece;
char c;
// we are enclosed, searching for second encloser	// we are enclosed, searching for second encloser
while(c=*read++) {	while(c=*read++) {
if(c==encloser) {	if(c==encloser) {
Line 275 static lsplit_result lsplit(char** strin	Line 362 static lsplit_result lsplit(char** strin
}	}
*write++=c;	*write++=c;
}	}
// we are no longer enclosed, searching for delimiter, skipping extra enclosers
	// we are no longer enclosed, searching for delimiter
while(c=*read++) {	while(c=*read++) {
if(c==delim1 \|\| c==delim2) {	if(c==delims[0] \|\| c==delims[1]) {
result.delim=c;	result.delim=c;
break;	break;
} else if(c!=encloser)	} else
*write++=c;	*write++=c;
}	}

*write=0; // terminate	*write=0; // terminate
*string_ref=c? read: 0;	*string_ref=c ? read : 0;
result.piece=string;
return result;	return result;
} else	} else
return lsplit(string_ref, delim1, delim2);	return lsplit(string_ref, delims);
}	}
result.piece=0;
return result;	return result;
}	}

static void skip_empty_and_comment_lines( char** data_ref ) {	static void skip_empty_and_comment_lines( char** data_ref ) {
if(char data=data_ref) {	while(*data_ref) {
while( char c=*data ) {	if(**data_ref == '\n'){
if( c== '\n' \|\| c == '#' ) {	(*data_ref)++;
/nowhere=/getrow(&data); // remove empty&comment lines	} else {
if(!(*data_ref=data))	if(**data_ref == '#' )
break;	/nowhere=/getrow(data_ref);
continue;	else
}	break;
break;
}	}
}	}
}	}

static void skip_empty_lines( char** data_ref ) {	static void skip_empty_lines( char** data_ref ) {
if(char data=data_ref) {	if(*data_ref) {
while( char c=*data ) {	while(**data_ref == '\n')
if( c== '\n' ) {	(*data_ref)++;
/nowhere=/getrow(&data); // remove empty lines
if(!(*data_ref=data))
break;
continue;
}
break;
}
}	}
}	}

Line 333 static void _load(Request& r, MethodPara	Line 412 static void _load(Request& r, MethodPara
size_t options_param_index=filename_param_index+1;	size_t options_param_index=filename_param_index+1;

HashStringValue *options=0;	HashStringValue *options=0;
TableSeparators separators;	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))) {	control_chars.load(*options);
// cloning, so that we could change [to simplify checks on params inside file_read_text
options=new HashStringValue(*options);
separators.load(*options);
}

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

Skip_lines_action skip_lines_action = (separators.column=='#' \|\| separators.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;

// parse columns	// parse columns
Table::columns_type columns;	Table::columns_type columns;
if(nameless) {	if(nameless) {
columns=Table::columns_type(0); // nameless	columns=0; // nameless
} else {	} else {
columns=Table::columns_type(new ArrayString);	columns=new ArrayString;

skip_lines_action(&data);	skip_lines_action(&data);
while( lsplit_result sr=lsplit(&data, separators.column, '\n', separators.encloser) ) {	while( lsplit_result sr=lsplit(&data, control_chars.separators, control_chars.encloser) ) {
*columns+=new String(sr.piece, String::L_TAINTED);	*columns+=new String(sr.piece, String::L_TAINTED);
if(sr.delim=='\n')	if(sr.delim=='\n')
break;	break;
Line 366 static void _load(Request& r, MethodPara	Line 437 static void _load(Request& r, MethodPara
}	}

Table& table=*new Table(columns);	Table& table=*new Table(columns);
int columns_count=columns? columns->count(): 0;	int columns_count=columns ? columns->count(): 0;

// parse cells	// parse cells
Table::element_type row(new ArrayString(columns_count));	Table::element_type row(new ArrayString(columns_count));
skip_lines_action(&data);	skip_lines_action(&data);
while( lsplit_result sr=lsplit(&data, separators.column, '\n', separators.encloser) ) {	while( lsplit_result sr=lsplit(&data, control_chars.separators, control_chars.encloser) ) {
if(!*sr.piece && !sr.delim && !row->count()) // append last empty column [if without \n]	if(!*sr.piece && !sr.delim && !row->count()) // append last empty column [if without \n]
break;	break;
*row+=new String(sr.piece, String::L_TAINTED);	*row+=new String(sr.piece, String::L_TAINTED);
Line 390 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 415 static void enclose( pa_stringstream& to	Line 485 static void enclose( pa_stringstream& to
}	}
}	}

static void table_to_csv(pa_stringstream& result, Table& table, TableSeparators& separators, bool output_column_names) {	static void table_to_csv(pa_stringstream& result, Table& table, TableControlChars& control_chars, bool output_column_names) {
if(output_column_names) {	if(output_column_names) {
if(table.columns()) { // named table	if(table.columns()) { // named table
if(separators.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(), separators.encloser );	enclose( result, i.next(), control_chars.encloser );
if(i.has_next())	if(i)
result<<separators.column;	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<<separators.column;	result<<control_chars.separator;
}	}
}	}
} else { // nameless table [we were asked to output column names]	} else { // nameless table [we were asked to output column names]
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(separators.encloser) {	if(control_chars.encloser) {
result<<separators.encloser<<column<<separators.encloser;	result<<control_chars.encloser<<column<<control_chars.encloser;
} else {	} else {
result<<column;	result<<column;
}	}
if(column<lsize-1){	if(column<lsize-1){
result<<separators.column;	result<<control_chars.separator;
}	}
}	}
else	else
Line 451 static void table_to_csv(pa_stringstream	Line 521 static void table_to_csv(pa_stringstream

// process data lines	// process data lines
Array_iterator<ArrayString*> i(table);	Array_iterator<ArrayString*> i(table);
if(separators.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(), separators.encloser );	enclose( result, c.next(), control_chars.encloser );
if(c.has_next())	if(c)
result<<separators.column;	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<<separators.column;	result<<control_chars.separator;
}	}
result<<'\n';	result<<'\n';
}	}
Line 494 void enclose( String& to, const String*	Line 564 void enclose( String& to, const String*
}	}
}	}

static void table_to_csv(String& result, Table& table, TableSeparators& separators, bool output_column_names) {	static void table_to_csv(String& result, Table& table, TableControlChars& control_chars, bool output_column_names) {
if(output_column_names) {	if(output_column_names) {
if(table.columns()) { // named table	if(table.columns()) { // named table
if(separators.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(), separators.encloser, separators.sencloser );	enclose( result, i.next(), control_chars.encloser, control_chars.sencloser );
if(i.has_next())	if(i)
result<<*separators.scolumn;	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<<*separators.scolumn;	result<<*control_chars.sseparator;
}	}
}	}
} else { // nameless table [we were asked to output column names]	} else { // nameless table [we were asked to output column names]
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(separators.encloser) {	if(control_chars.encloser) {
result<<separators.sencloser<<String::Body::Format(column)<<separators.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<<*separators.scolumn;	result<<*control_chars.sseparator;
}	}
}	}
else	else
Line 530 static void table_to_csv(String& result,	Line 600 static void table_to_csv(String& result,

// data lines	// data lines
Array_iterator<ArrayString*> i(table);	Array_iterator<ArrayString*> i(table);
if(separators.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(), separators.encloser, separators.sencloser );	enclose( result, c.next(), control_chars.encloser, control_chars.sencloser );
if(c.has_next())	if(c)
result<<*separators.scolumn;	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<<*separators.scolumn;	result<<*control_chars.sseparator;
}	}
result.append_know_length("\n", 1, String::L_CLEAN);	result.append_know_length("\n", 1, String::L_CLEAN);
}	}
Line 569 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;

TableSeparators separators;	TableControlChars control_chars;
if(param_index<params.count())	if(param_index<params.count())
if(HashStringValue* options=params.as_hash(param_index++)) {	if(HashStringValue* options=params.as_hash(param_index++)) {
int valid_options=separators.load(*options);	int valid_options=control_chars.load(*options);
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);
}	}

if(param_index<params.count())	if(param_index<params.count())
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "bad mode (must be nameless or append)");
0,
"bad mode (must be nameless or append)");

Table& table=GET_SELF(r, VTable).table();	Table& table=GET_SELF(r, VTable).table();

#ifdef USE_STRINGSTREAM	#ifdef USE_STRINGSTREAM
pa_stringstream ost(std::stringstream::out);	pa_stringstream ost(std::stringstream::out);

table_to_csv(ost, table, separators, output_column_names);	table_to_csv(ost, table, control_chars, output_column_names);

// write	// write
pa_string data=ost.str();	pa_string data=ost.str();
Line 601 static void _save(Request& r, MethodPara	Line 669 static void _save(Request& r, MethodPara
#else	#else
String sdata;	String sdata;

table_to_csv(sdata, table, separators, output_column_names);	table_to_csv(sdata, table, control_chars, output_column_names);

// write	// write
const char* data_cstr=sdata.cstr();	const char* data_cstr=sdata.cstr();
Line 619 static void _csv_string(Request& r, Meth	Line 687 static void _csv_string(Request& r, Meth
output_column_names=false;	output_column_names=false;
param_index++;	param_index++;
} else {	} else {
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "bad mode (must be nameless)");
0,
"bad mode (must be nameless)");
}	}
}	}

TableSeparators separators;	TableControlChars control_chars;
if(param_index<params.count())	if(param_index<params.count())
if(HashStringValue* options=params.as_hash(param_index++)) {	if(HashStringValue* options=params.as_hash(param_index++)) {
int valid_options=separators.load(*options);	int valid_options=control_chars.load(*options);
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 638 static void _csv_string(Request& r, Meth	Line 704 static void _csv_string(Request& r, Meth
#ifdef USE_STRINGSTREAM	#ifdef USE_STRINGSTREAM
pa_stringstream ost(std::stringstream::out);	pa_stringstream ost(std::stringstream::out);

table_to_csv(ost, table, separators, output_column_names);	table_to_csv(ost, table, control_chars, output_column_names);

r.write_no_lang(new VString(new String(pa_strdup(ost.str().c_str()), String::L_CLEAN)));	r.write(new VString(new String(pa_strdup(ost.str().c_str()), String::L_CLEAN)));
#else	#else
String sdata;	String sdata;

table_to_csv(sdata, table, separators, output_column_names);	table_to_csv(sdata, table, control_chars, output_column_names);

r.write_no_lang(new VString(new String(sdata.cstr(), String::L_CLEAN)));	r.write(new VString(new String(sdata.cstr(), String::L_CLEAN)));
#endif	#endif
}	}

Line 656 static void _count(Request& r, MethodPar	Line 722 static void _count(Request& r, MethodPar
if(params.count()) {	if(params.count()) {
const String& param=params.as_string(0, PARAMETER_MUST_BE_STRING);	const String& param=params.as_string(0, PARAMETER_MUST_BE_STRING);
if(param == "columns")	if(param == "columns")
result = table.columns() ? table.columns()->count() : 0;	result = table.columns() ? table.columns()->count() : table.max_cells();
else if(param == "cells")	else if(param == "cells")
result = table.count() ? table[table.current()]->count() : 0;	result = table.count() ? table[table.current()]->count() : 0;
else if(param == "rows") // synonim for ^table.count[]	else if(param == "rows") // synonim for ^table.count[]
Line 666 static void _count(Request& r, MethodPar	Line 732 static void _count(Request& r, MethodPar
} else	} else
result = table.count();	result = table.count();

r.write_no_lang(*new VInt(result));	r.write(*new VInt(result));
}	}

static void _line(Request& r, MethodParams&) {	static void _line(Request& r, MethodParams&) {
int result=1+GET_SELF(r, VTable).table().current();	int result=1+GET_SELF(r, VTable).table().current();
r.write_no_lang(*new VInt(result));	r.write(*new VInt(result));
}	}

static void _offset(Request& r, MethodParams& params) {	static void _offset(Request& r, MethodParams& params) {
Line 685 static void _offset(Request& r, MethodPa	Line 751 static void _offset(Request& r, MethodPa
else if(whence=="set")	else if(whence=="set")
absolute=true;	absolute=true;
else	else
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, &whence, "is an invalid whence, valid are 'cur' or 'set'");
&whence,
"is invalid whence, valid are 'cur' or 'set'");
}	}

int offset=params.as_int(params.count()-1, "offset must be expression", r);	int offset=params.as_int(params.count()-1, "offset must be expression", r);
table.offset(absolute, offset);	table.offset(absolute, offset);
} else	} else
r.write_no_lang(*new VInt(table.current()));	r.write(*new VInt(table.current()));
}	}

static void _menu(Request& r, MethodParams& params) {	static void _menu(Request& r, MethodParams& params) {
Line 705 static void _menu(Request& r, MethodPara	Line 769 static void _menu(Request& r, MethodPara

Table& table=GET_SELF(r, VTable).table();	Table& table=GET_SELF(r, VTable).table();
size_t saved_current=table.current();	size_t saved_current=table.current();
size_t size=table.count();

if(delim_maybe_code) { // delimiter set	if(delim_maybe_code) { // delimiter set
bool need_delim=false;	bool need_delim=false;
for(size_t row=0; row<size; row++) {	for(size_t row=0; row<table.count(); row++) {
table.set_current(row);	table.set_current(row);

StringOrValue 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
if(need_delim) // need delim & iteration produced string?	if(need_delim) // need delim & iteration produced string?
r.write_pass_lang(r.process(*delim_maybe_code));	r.write(r.process(*delim_maybe_code));
else	else
need_delim=true;	need_delim=true;
}	}

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

if(lskip==Request::SKIP_BREAK)	if(skip.check_break())
break;	break;
}	}
} else {	} else {
for(size_t row=0; row<size; row++) {	for(size_t row=0; row<table.count(); row++) {
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 749 struct Row_info {	Line 811 struct Row_info {
Value* key_code;	Value* key_code;
size_t key_field;	size_t key_field;
Array<int>* value_fields;	Array<int>* value_fields;
	Value* value_code;
HashStringValue* hash;	HashStringValue* hash;
Table2hash_distint distinct;	Table2hash_distint distinct;
size_t row;	size_t row;
Line 759 static void table_row_to_hash(Table::ele	Line 822 static void table_row_to_hash(Table::ele
const String* key;	const String* key;
if(info->key_code) {	if(info->key_code) {
info->table->set_current(info->row++); // change context row	info->table->set_current(info->row++); // change context row
StringOrValue 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 771 static void table_row_to_hash(Table::ele	Line 834 static void table_row_to_hash(Table::ele
bool exist=false;	bool exist=false;
switch(info->value_type) {	switch(info->value_type) {
case C_STRING: {	case C_STRING: {
size_t index=info->value_fields->get(0);	if(info->value_fields->count()){
exist=info->hash->put_dont_replace(key, (index < row->count()) ? new VString(row->get(index)) : new VString());	size_t index=info->value_fields->get(0);
	exist=info->hash->put_dont_replace(key, (index < row->count()) ? new VString(row->get(index)) : VString::empty());
	} else {
	exist=info->hash->put_dont_replace(*key, VString::empty());
	}
break;	break;
}	}
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(	size_t value_field=i.next();
*info->table->columns()->get(value_field),	if(value_field<row->count())
new VString(*row->get(value_field)));	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 804 static void table_row_to_hash(Table::ele	Line 875 static void table_row_to_hash(Table::ele
table=new Table(info->table, table_options/no rows, just structure*/);	table=new Table(info->table, table_options/no rows, just structure*/);
info->hash->put(*key, new VTable(table));	info->hash->put(*key, new VTable(table));
}	}
*table+=row;	Table::element_type row_copy(new ArrayString(row->count()));
	row_copy->append(*row);
	*table+=row_copy;
	break;
	}
	case C_CODE: {
	if(!info->key_code)
	info->table->set_current(info->row++); // change context row
	exist=info->hash->put_dont_replace(key, &info->r->process(info->value_code));
break;	break;
}	}
}	}
if(exist && info->distinct==D_ILLEGAL)	if(exist && info->distinct==D_ILLEGAL)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, key, "duplicate key");
key,
"duplicate key");
}	}

Table2hash_value_type get_value_type(Value& vvalue_type){	Table2hash_value_type get_value_type(Value& vvalue_type){
Line 824 Table2hash_value_type get_value_type(Val	Line 901 Table2hash_value_type get_value_type(Val
} else if (svalue_type == "hash") {	} else if (svalue_type == "hash") {
return C_HASH;	return C_HASH;
} else {	} else {
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, &svalue_type, "must be 'hash', 'table' or 'string'");
&svalue_type,
"must be 'hash', 'table' or 'string'");
}	}
} else {	} else {
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "'type' must be string");
0,	}
"'type' must be hash");	}

	static Table2hash_distint get_distinct(Value& vdistinct, Table2hash_value_type& value_type){
	if(vdistinct.is_string()) {
	const String& sdistinct=*vdistinct.get_string();
	if(sdistinct!="tables")
	throw Exception(PARSER_RUNTIME, &sdistinct, "must be 'tables' or true/false");
	value_type=C_TABLE;
	return D_FIRST;
}	}
	return vdistinct.as_bool() ? D_FIRST : D_ILLEGAL;
}	}

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(HashStringValue* options=params.as_no_junction(param_index, PARAM_MUST_NOT_BE_CODE).get_hash()){ // can't use .as_has 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++;
Value& vdistinct_value=r.process_to_value(*vdistinct_code);
if(vdistinct_value.is_string()) {
const String& sdistinct=*vdistinct_value.get_string();
if(sdistinct=="tables") {
value_type=C_TABLE;
distinct=D_FIRST;
} else {
throw Exception(PARSER_RUNTIME,
&sdistinct,
"must be 'tables' or true/false");
}
} else {
distinct=vdistinct_value.as_bool()?D_FIRST:D_ILLEGAL;
}
}
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");

valid_options++;	Table2hash_distint distinct=D_ILLEGAL;
value_type=get_value_type(r.process_to_value(*vvalue_type_code));	Table2hash_value_type value_type=C_HASH;
}

if(valid_options!=options->count())	int param_index=params.count()-1;
throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);	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 was 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
if(param_index==0){ // list of columns wasn't specified	throw Exception(PARSER_RUNTIME, 0, "options must be hash");
if(value_type==C_STRING) // $.type[string]
throw Exception(PARSER_RUNTIME,
0,
"you must specify one value field with option $.type[string]");

for(size_t i=0; i<columns->count(); i++) // by all columns, including key
value_fields+=i;

} else { // list of columns was specified
if(value_type==C_TABLE)
throw Exception(PARSER_RUNTIME,
0,
"you can't specify value field(s) with option $.distinct[tables] or $.type[tables]");

Value& value_fields_param=params.as_no_junction(param_index, "value field(s) must not be code");
if(value_fields_param.is_string()) { // one column as string was specified
value_fields+=self_table.column_name2index(*value_fields_param.get_string(), true);
} else if(Table* value_fields_table=value_fields_param.get_table()) { // list of columns were specified in table
for(Array_iterator<Table::element_type> i(*value_fields_table); i.has_next(); ) {
const String& value_field_name =*i.next()->get(0);
value_fields +=self_table.column_name2index(value_field_name, true);
}
} else
throw Exception(PARSER_RUNTIME,
0,
"value field(s) must be string or table");
}

if(value_type==C_STRING && value_fields.count()!=1)
throw Exception(PARSER_RUNTIME,
0,
"you can specify only one value field with option $.type[string]");

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

int saved_current=self_table.current();
self_table.for_each(table_row_to_hash, &info);
self_table.set_current(saved_current);

result.extract_default();	bool value_all=false;
	Array<int> value_fields;
	Value* value_code=0;

	if(param_index==0){ // list of columns wasn't specified
	if(value_type==C_STRING)
	throw Exception(PARSER_RUNTIME, 0, "you must specify one value field with option $.type[string]");

	value_all=true; // all columns, including key
	} else { // list of columns or code was specified
	if(value_type==C_TABLE)
	throw Exception(PARSER_RUNTIME, 0, "you can't specify value field(s) with option $.distinct[tables] or $.type[tables]");

	Value& value_fields_param=params[1];
	if(value_fields_param.get_junction()){ // code specified
	value_code=&value_fields_param;
	} else if(value_fields_param.is_string()) { // one column as string was specified
	const String &field_name=*value_fields_param.get_string();
	if(!field_name.is_empty())
	value_fields+=self_table.column_name2index(field_name, true);
	} else if(Table* value_fields_table=value_fields_param.get_table()) { // list of columns were specified in table
	for(Array_iterator<Table::element_type> i(*value_fields_table); i; ) {
	const String& value_field_name =*i.next()->get(0);
	value_fields +=self_table.column_name2index(value_field_name, true);
}	}
}	} 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)
	throw Exception(PARSER_RUNTIME, 0, "you can't specify more than one value field with option $.type[string]");
	}

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

	int saved_current=self_table.current();
	self_table.for_each(table_row_to_hash, &info);
	self_table.set_current(saved_current);

	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_no_lang(result);
	result_array.confirm_all_used();
	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 972 static int sort_cmp_double(const void *a	Line 1063 static int sort_cmp_double(const void *a
static void _sort(Request& r, MethodParams& params) {	static void _sort(Request& r, MethodParams& params) {
Value& key_maker=params.as_junction(0, "key-maker must be code");	Value& key_maker=params.as_junction(0, "key-maker must be code");

bool reverse=params.count()>1/..[desc\|asc\|]/?	bool reverse=params.count()>1 /..[desc\|asc\|]/ && params.as_no_junction(1, "order must not be code").as_string()=="desc"; // default=asc
reverse=params.as_no_junction(1, "order must not be code").as_string()=="desc":
false; // default=asc

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 989 static void _sort(Request& r, MethodPara	Line 1078 static void _sort(Request& r, MethodPara
old_table.set_current(i);	old_table.set_current(i);
// calculate key value	// calculate key value
seq[i].row=old_table[i];	seq[i].row=old_table[i];
Value& value=r.process_to_value(key_maker);	Value& value=r.process(key_maker);
if(i==0) // determining key values type by first one	if(i==0) // determining key values type by first one
key_values_are_strings=value.is_string();	key_values_are_strings=value.is_string();

Line 1003 static void _sort(Request& r, MethodPara	Line 1092 static void _sort(Request& r, MethodPara
if(r.charsets.source().NAME()=="KOI8-R" && key_values_are_strings) {	if(r.charsets.source().NAME()=="KOI8-R" && key_values_are_strings) {
for(i=0; i<old_count; i++)	for(i=0; i<old_count; i++)
if(*seq[i].value.c_str)	if(*seq[i].value.c_str)
seq[i].value.c_str=Charset::transcode(seq[i].value.c_str, r.charsets.source(), UTF8_charset).cstr();	seq[i].value.c_str=Charset::transcode(seq[i].value.c_str, r.charsets.source(), pa_UTF8_charset).cstr();
}	}

// sort keys	// sort keys
Line 1027 struct Expression_is_true_info {	Line 1116 struct Expression_is_true_info {
#endif	#endif

static bool expression_is_true(Table&, Expression_is_true_info* info) {	static bool expression_is_true(Table&, Expression_is_true_info* info) {
return info->r->process_to_value(*info->expression_code).as_bool();	return info->r->process(*info->expression_code).as_bool();
}	}

static bool _locate_expression(Table& table, Request& r, MethodParams& params) {	static bool _locate_expression(Table& table, Request& r, MethodParams& params) {
Line 1052 static void _locate(Request& r, MethodPa	Line 1141 static void _locate(Request& r, MethodPa
bool result=params[0].get_junction() \|\| (params.count() == 1) ?	bool result=params[0].get_junction() \|\| (params.count() == 1) ?
_locate_expression(table, r, params) :	_locate_expression(table, r, params) :
_locate_name_value(table, r, params);	_locate_name_value(table, r, params);
r.write_no_lang(VBool::get(result));	r.write(VBool::get(result));
}	}


Line 1060 static void _flip(Request& r, MethodPara	Line 1149 static void _flip(Request& r, MethodPara
Table& old_table=GET_SELF(r, VTable).table();	Table& old_table=GET_SELF(r, VTable).table();
Table& new_table=*new Table(0);	Table& new_table=*new Table(0);
if(size_t old_count=old_table.count())	if(size_t old_count=old_table.count())
if(size_t old_cols=old_table.columns()?old_table.columns()->count():old_table[0]->count())	if(size_t old_cols=old_table.columns()?old_table.columns()->count():old_table.max_cells())
for(size_t column=0; column<old_cols; column++) {	for(size_t column=0; column<old_cols; column++) {
Table::element_type new_row(new ArrayString(old_count));	Table::element_type new_row(new ArrayString(old_count));
for(size_t i=0; i<old_count; i++) {	for(size_t i=0; i<old_count; i++) {
Line 1070 static void _flip(Request& r, MethodPara	Line 1159 static void _flip(Request& r, MethodPara
new_table+=new_row;	new_table+=new_row;
}	}

r.write_no_lang(*new VTable(&new_table));	r.write(*new VTable(&new_table));
}	}

static void _foreach(Request& r, MethodParams& params) {	static void _foreach(Request& r, MethodParams& params) {
InCycle temp(r);	InCycle temp(r);

const String& rownum_name=params.as_string(0, "rownum-var name must be string");	const String* rownum_var_name=&params.as_string(0, "rownum-var name must be string");
const String& value_name=params.as_string(1, "value-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& body_code=params.as_junction(2, "body must be code");

Line 1085 static void _foreach(Request& r, MethodP	Line 1174 static void _foreach(Request& r, MethodP

Table& table=GET_SELF(r, VTable).table();	Table& table=GET_SELF(r, VTable).table();
size_t saved_current=table.current();	size_t saved_current=table.current();
size_t size=table.count();

const String* rownum_var_name=rownum_name.is_empty()? 0 : &rownum_name;	rownum_var_name=rownum_var_name->is_empty()? 0 : rownum_var_name;
const String* value_var_name=value_name.is_empty()? 0 : &value_name;	value_var_name=value_var_name->is_empty()? 0 : value_var_name;

Value* var_context=r.get_method_frame()->caller();	Value* var_context=r.get_method_frame()->caller();

if(delim_maybe_code) { // delimiter set	if(delim_maybe_code) { // delimiter set
bool need_delim=false;	bool need_delim=false;
for(size_t row=0; row<size; row++) {	for(size_t row=0; row<table.count(); row++) {
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));

StringOrValue 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
if(need_delim) // need delim & iteration produced string?	if(need_delim) // need delim & iteration produced string?
r.write_pass_lang(r.process(*delim_maybe_code));	r.write(r.process(*delim_maybe_code));
else	else
need_delim=true;	need_delim=true;
}	}

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

if(lskip==Request::SKIP_BREAK)	if(skip.check_break())
break;	break;
}	}
} else {	} else {
for(size_t row=0; row<size; row++) {	for(size_t row=0; row<table.count(); row++) {
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;
}	}
}	}
table.set_current(saved_current);	table.set_current(saved_current);
}	}

static void _append(Request& r, MethodParams& params) {	static void update_cell(HashStringValue::key_type aname, HashStringValue::value_type avalue, VTable *dest) {
Temp_lang temp_lang(r, String::L_PASS_APPENDED);	dest->put_element(String(aname, String::L_CLEAN), avalue); // new not required
const String& string=r.process_to_string(params[0]);	}

	inline Table::element_type row_from_string(Request& r, Value &param){
	if(!param.is_string() && !param.get_junction())
	throw Exception(PARSER_RUNTIME, 0, "row must be string, code or hash");

	const String& string=r.process_to_string(param);

// parse cells	// parse cells
Table::element_type row=new ArrayString;	Table::element_type row=new ArrayString;
size_t pos_after=0;	string.split(*row, 0, "\t", String::L_AS_IS);
string.split(*row, pos_after, "\t", String::L_AS_IS);

GET_SELF(r, VTable).table()+=row;	return row;
}	}

static void _insert(Request& r, MethodParams& params) {	static void _append(Request& r, MethodParams& params) {
Temp_lang temp_lang(r, String::L_PASS_APPENDED);	VTable vtable=GET_SELF(r, VTable);
const String& string=r.process_to_string(params[0]);	Table& table=vtable.table();

// parse cells	HashStringValue* hash=params[0].get_hash();
Table::element_type row=new ArrayString;	if(hash){
size_t pos_after=0;	table+=new ArrayString();
string.split(*row, pos_after, "\t", String::L_AS_IS);	size_t saved_current=table.current();
	table.set_current(table.count()-1);
	hash->for_each<VTable*>(update_cell, &vtable);
	table.set_current(saved_current);
	} else {
	table+=row_from_string(r, params[0]);
	}
	}

Table& table=GET_SELF(r, VTable).table();	static void _insert(Request& r, MethodParams& params) {
table.insert(table.current(), row);	VTable vtable=GET_SELF(r, VTable);
	Table& table=vtable.table();
	HashStringValue* hash=params[0].get_hash();
	if(hash){
	table.insert(table.current(), new ArrayString());
	hash->for_each<VTable*>(update_cell, &vtable);
	} else {
	table.insert(table.current(), row_from_string(r, params[0]));
	}
}	}

static void _delete(Request& r, MethodParams& params) {	static void _delete(Request& r, MethodParams&) {
Table& table=GET_SELF(r, VTable).table();	Table& table=GET_SELF(r, VTable).table();
table.remove_current();	table.remove_current();
}	}
Line 1181 static void join_nameless_row(Table& src	Line 1288 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,	throw Exception(PARSER_RUNTIME, 0, "source and destination are same table");
0,
"source and destination are same table");	if(dest.columns()) // dest is named
	src->table_for_each(join_named_row, &dest, o);
if(dest.columns()) // dest is named	else // dest is nameless
src.table_for_each(join_named_row, &dest, o);	src->table_for_each(join_nameless_row, &dest, o);
else // dest is nameless	}
src.table_for_each(join_nameless_row, &dest, o);
}	}

#ifndef DOXYGEN	#ifndef DOXYGEN
Line 1214 public:	Line 1319 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 1233 public:	Line 1342 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 1242 public:	Line 1351 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 1266 static void marshal_bind(	Line 1371 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 1301 static void _sql(Request& r, MethodParam	Line 1406 static void _sql(Request& r, MethodParam
}	}
if(Value* vlimit=options->get(sql_limit_name)) {	if(Value* vlimit=options->get(sql_limit_name)) {
valid_options++;	valid_options++;
limit=(ulong)r.process_to_value(*vlimit).as_double();	limit=(ulong)r.process(*vlimit).as_double();
}	}
if(Value* voffset=options->get(sql_offset_name)) {	if(Value* voffset=options->get(sql_offset_name)) {
valid_options++;	valid_options++;
offset=(ulong)r.process_to_value(*voffset).as_double();	offset=(ulong)r.process(*voffset).as_double();
}	}
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 1316 static void _sql(Request& r, MethodParam	Line 1421 static void _sql(Request& r, MethodParam
if(bind)	if(bind)
placeholders_count=marshal_binds(*bind, placeholders);	placeholders_count=marshal_binds(*bind, placeholders);

Temp_lang temp_lang(r, String::L_SQL);
const String& statement_string=r.process_to_string(statement);	const String& statement_string=r.process_to_string(statement);
const char* statement_cstr=statement_string.untaint_cstr(r.flang, r.connection());	const char* statement_cstr=statement_string.untaint_cstr(String::L_SQL, r.connection());

Table_sql_event_handlers handlers;	Table_sql_event_handlers handlers;

Line 1353 static void _columns(Request& r, MethodP	Line 1457 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;
}	}
}	}

r.write_no_lang(*new VTable(&result_table));	r.write(*new VTable(&result_table));
}	}

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 1377 static void _select(Request& r, MethodPa	Line 1482 static void _select(Request& r, MethodPa
int valid_options=0;	int valid_options=0;
if(Value* vlimit=options->get(sql_limit_name)) {	if(Value* vlimit=options->get(sql_limit_name)) {
valid_options++;	valid_options++;
limit=r.process_to_value(*vlimit).as_int();	limit=r.process(*vlimit).as_int();
}	}
if(Value* voffset=options->get(sql_offset_name)) {	if(Value* voffset=options->get(sql_offset_name)) {
valid_options++;	valid_options++;
offset=r.process_to_value(*voffset).as_int();	offset=r.process(*voffset).as_int();
}	}
if(Value* vreverse=options->get(table_reverse_name)) {	if(Value* vreverse=options->get(table_reverse_name)) {
valid_options++;	valid_options++;
reverse=r.process_to_value(*vreverse).as_bool();	reverse=r.process(*vreverse).as_bool();
}	}
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 1404 static void _select(Request& r, MethodPa	Line 1509 static void _select(Request& r, MethodPa
for(size_t row=size-1; result_table.count() < (size_t)limit; row--) {	for(size_t row=size-1; result_table.count() < (size_t)limit; row--) {
source_table.set_current(row);	source_table.set_current(row);

bool condition=r.process_to_value(vcondition, false/don't intercept string/).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 1414 static void _select(Request& r, MethodPa	Line 1522 static void _select(Request& r, MethodPa
for(size_t row=0; row < size && result_table.count() < (size_t)limit; row++) {	for(size_t row=0; row < size && result_table.count() < (size_t)limit; row++) {
source_table.set_current(row);	source_table.set_current(row);

bool condition=r.process_to_value(vcondition, false/don't intercept string/).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 1423 static void _select(Request& r, MethodPa	Line 1534 static void _select(Request& r, MethodPa
source_table.set_current(saved_current);	source_table.set_current(saved_current);
}	}

r.write_no_lang(*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
Line 1473 MTable::MTable(): Methoded("table") {	Line 1620 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 1509 MTable::MTable(): Methoded("table") {	Line 1660 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.307
changed lines
	Added in v.1.371