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.329 and 1.347

version 1.329, 2016/09/21 00:44:50	version 1.347, 2019/09/06 10:17:07
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-2017 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
*/	*/

Line 17	Line 17
#include "pa_vbool.h"	#include "pa_vbool.h"
#include "pa_array.h"	#include "pa_array.h"

#if (!defined(NO_STRINGSTREAM) && !defined(FREEBSD4))	#if (!defined(NO_STRINGSTREAM) && !defined(FREEBSD4) && !defined(PA_DEBUG_DISABLE_GC))
#include <sstream>	#include <sstream>
#define USE_STRINGSTREAM	#define USE_STRINGSTREAM
#endif	#endif
Line 37 public:	Line 37 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 74 static Table::Action_options get_action_	Line 67 static Table::Action_options get_action_
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_to_value(*voffset).as_int();	result.offset=r.process(*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();	result.limit=r.process(*vlimit).as_int();
}	}
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;
}	}
Line 160 public:	Line 153 public:

String extract(char pos){	String extract(char pos){
String *result=new String;	String *result=new String;
// first: their langs	if(size_t len=strlen(pos)){
result->langs.append(result->body, langs, pos-base, strlen(pos));	// first: their langs
// next: letters themselves	result->langs.append(result->body, langs, pos-base, len);
result->body=Body(pos);	// next: letters themselves
	result->body=Body(pos);
	}
return result;	return result;
}	}
};	};
Line 201 static lsplit_sresult lsplit(char** stri	Line 196 static lsplit_sresult lsplit(char** stri
*(pos++)=0;	*(pos++)=0;
result.append(helper.extract(*string_ref));	result.append(helper.extract(*string_ref));
if(*pos==encloser && helper.check_lang(pos)){ // double-encloser stands for encloser	if(*pos==encloser && helper.check_lang(pos)){ // double-encloser stands for encloser
*string_ref=++pos;	*string_ref=pos;
} else {	} else {
*string_ref=pos;	*string_ref=pos;
break;	break;
}	}
}	}
	pos++;
} else {	} else {
result.append(helper.extract(*string_ref));	result.append(helper.extract(*string_ref));
*string_ref=0;	*string_ref=0;
Line 275 static void _create(Request& r, MethodPa	Line 271 static void _create(Request& r, MethodPa
}	}

// 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")));	StringSplitHelper sdata(r.process_to_string(params.as_junction(data_param_index, "body must be table or code")));
char *data=sdata.base;	char *data=sdata.base;

Line 463 static void _load(Request& r, MethodPara	Line 458 static void _load(Request& r, MethodPara
}	}

#ifdef USE_STRINGSTREAM	#ifdef USE_STRINGSTREAM
#include "gc_allocator.h"	#include "../lib/gc/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 709 static void _csv_string(Request& r, Meth	Line 704 static void _csv_string(Request& r, Meth

table_to_csv(ost, table, control_chars, 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, control_chars, 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 735 static void _count(Request& r, MethodPar	Line 730 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 760 static void _offset(Request& r, MethodPa	Line 755 static void _offset(Request& r, MethodPa
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 778 static void _menu(Request& r, MethodPara	Line 773 static void _menu(Request& r, MethodPara
for(size_t row=0; row<table.count(); 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 {
Line 799 static void _menu(Request& r, MethodPara	Line 794 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 826 static void table_row_to_hash(Table::ele	Line 820 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;
Line 881 static void table_row_to_hash(Table::ele	Line 875 static void table_row_to_hash(Table::ele
case C_CODE: {	case C_CODE: {
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
exist=info->hash->put_dont_replace(key, &info->r->process(info->value_code).as_value());	exist=info->hash->put_dont_replace(key, &info->r->process(info->value_code));
break;	break;
}	}
}	}
Line 935 static void _hash(Request& r, MethodPara	Line 929 static void _hash(Request& r, MethodPara
int valid_options=0;	int valid_options=0;
if(Value* vdistinct_code=options->get(sql_distinct_name)) { // $.distinct ?	if(Value* vdistinct_code=options->get(sql_distinct_name)) { // $.distinct ?
valid_options++;	valid_options++;
distinct=get_distinct(r.process_to_value(*vdistinct_code), value_type);	distinct=get_distinct(r.process(*vdistinct_code), value_type);
}	}
if(Value* vvalue_type_code=options->get(sql_value_type_name)) { // $.type ?	if(Value* vvalue_type_code=options->get(sql_value_type_name)) { // $.type ?
if(value_type==C_TABLE) // $.distinct[tables] already was specified	if(value_type==C_TABLE) // $.distinct[tables] already was specified
Line 943 static void _hash(Request& r, MethodPara	Line 937 static void _hash(Request& r, MethodPara
if(value_type==C_CODE)	if(value_type==C_CODE)
throw Exception(PARSER_RUNTIME, 0, "you can't specify $.type[] if value is code");	throw Exception(PARSER_RUNTIME, 0, "you can't specify $.type[] if value is code");
valid_options++;	valid_options++;
value_type=get_value_type(r.process_to_value(*vvalue_type_code));	value_type=get_value_type(r.process(*vvalue_type_code));
}	}

if(valid_options!=options->count())	if(valid_options!=options->count())
Line 984 static void _hash(Request& r, MethodPara	Line 978 static void _hash(Request& r, MethodPara
throw Exception(PARSER_RUNTIME, 0, "value field(s) must be string or table or code");	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 specify only one value field with option $.type[string]");	throw Exception(PARSER_RUNTIME, 0, "you can't specify more then one value field with option $.type[string]");

{	{
Value* key_param=&params[0];	Value* key_param=&params[0];
Line 1011 static void _hash(Request& r, MethodPara	Line 1005 static void _hash(Request& r, MethodPara
}	}
}	}
}	}
r.write_no_lang(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 1042 static int sort_cmp_double(const void *a	Line 1036 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 1059 static void _sort(Request& r, MethodPara	Line 1051 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 1073 static void _sort(Request& r, MethodPara	Line 1065 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 1097 struct Expression_is_true_info {	Line 1089 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 1122 static void _locate(Request& r, MethodPa	Line 1114 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 1140 static void _flip(Request& r, MethodPara	Line 1132 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 1156 static void _foreach(Request& r, MethodP	Line 1148 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();

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();

Line 1171 static void _foreach(Request& r, MethodP	Line 1163 static void _foreach(Request& r, MethodP
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 {
Line 1197 static void _foreach(Request& r, MethodP	Line 1189 static void _foreach(Request& r, MethodP
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 1214 inline Table::element_type row_from_stri	Line 1205 inline Table::element_type row_from_stri
if(!param.is_string() && !param.get_junction())	if(!param.is_string() && !param.get_junction())
throw Exception(PARSER_RUNTIME, 0, "row must be string, code or hash");	throw Exception(PARSER_RUNTIME, 0, "row must be string, code or hash");

Temp_lang temp_lang(r, String::L_PASS_APPENDED);
const String& string=r.process_to_string(param);	const String& string=r.process_to_string(param);

// parse cells	// parse cells
Line 1302 public:	Line 1292 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;
}	}
}	}
Line 1312 public:	Line 1302 public:
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 1321 public:	Line 1311 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 1330 public:	Line 1320 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 1354 static void marshal_bind(	Line 1340 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 1389 static void _sql(Request& r, MethodParam	Line 1375 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 1404 static void _sql(Request& r, MethodParam	Line 1390 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 1448 static void _columns(Request& r, MethodP	Line 1433 static void _columns(Request& r, MethodP
}	}
}	}

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) {
Line 1465 static void _select(Request& r, MethodPa	Line 1450 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 1492 static void _select(Request& r, MethodPa	Line 1477 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(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 1502 static void _select(Request& r, MethodPa	Line 1487 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(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 1511 static void _select(Request& r, MethodPa	Line 1496 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));
}	}

// constructor	// constructor

E-mail:

Removed from v.1.329
changed lines
	Added in v.1.347