--- parser3/src/classes/table.C 2002/04/18 10:51:00 1.151 +++ parser3/src/classes/table.C 2003/02/07 14:38:05 1.172.2.6 @@ -1,13 +1,15 @@ /** @file Parser: @b table parser class. - Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com) + Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com) Author: Alexandr Petrosian (http://paf.design.ru) - - $Id: table.C,v 1.151 2002/04/18 10:51:00 paf Exp $ */ +static const char* IDENT_TABLE_C="$Date: 2003/02/07 14:38:05 $"; + #include "classes.h" +#include "pa_vmethod_frame.h" + #include "pa_common.h" #include "pa_request.h" #include "pa_vtable.h" @@ -19,92 +21,151 @@ class MTable : public Methoded { public: // VStateless_class - Value *create_new_value(Pool& pool) { return new(pool) VTable(pool); } + ValuePtr create_new_value() { return ValuePtr(new VTable()); } public: - MTable(Pool& pool); + MTable(); public: // Methoded bool used_directly() { return true; } }; +// global variable + +MethodedPtr table_class(new MTable); + // methods -static void _create(Request& r, const String& method_name, MethodParams *params) { +static void get_copy_options(Request& r, StringPtr method_name, MethodParams& params, int param_index, + const Table& source, + int& offset, + int& limit) { + Pool& pool=r.pool(); + + offset=0; + limit=0; + if(params.count()<=param_index) + return; + + ValuePtr voptions=params.as_no_junction(param_index, "options must be hash, not code"); + if(!voptions->is_string()) { + if(HashStringValue* options=voptions->get_hash(method_name)) { + int valid_options=0; + if(ValuePtr voffset=options->get(sql_offset_name)) { + valid_options++; + if(voffset->is_string()) { + StringPtr soffset=voffset->get_string(&pool); + if(*soffset == "cur") + offset=source.current(); + else + throw Exception("parser.runtime", + soffset, + "must be 'cur' string or expression"); + } else + offset=r.process_to_value(voffset)->as_int(); + } + if(ValuePtr vlimit=options->get(sql_limit_name)) { + valid_options++; + limit=r.process_to_value(vlimit)->as_int(); + } + if(valid_options!=options->count()) + throw Exception("parser.runtime", + method_name, + "called with invalid option"); + } else + throw Exception("parser.runtime", + method_name, + "options must be hash"); + } + if(!limit) // zero limit = sould be 'nothing to copy', for methods zero means 'all' + limit=-1; // thus fixing +} + +static void _create(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); - // clone? - if(params->size()==1) - if(const Table *source=params->get(0).get_table()) { - static_cast(r.self)->set_table(*new(pool) Table(*source)); - return; - } + // clone/copy part? + if(const Table *source=params[0]->get_table()) { + int offset, limit; + get_copy_options(r, method_name, params, 1, *source, + offset, limit); + GET_SELF(r, VTable).set_table(TablePtr(new Table(*source, offset, limit))); + return; + } // data is last parameter Temp_lang temp_lang(r, String::UL_PASS_APPENDED); - const String& data= - r.process_to_string(params->as_junction(params->size()-1, "body must be code")); + StringPtr data= + r.process_to_string(params.as_junction(params.count()-1, "body must be code")); size_t pos_after=0; // parse columns - Array *columns; - if(params->size()==2) { - columns=0; + Table::columns_type columns; + if(params.count()==2) { + columns=Table::columns_type(0); // nameless } else { - columns=new(pool) Array(pool); + columns=Table::columns_type(new ArrayString); - Array head(pool); - data.split(head, &pos_after, "\n", 1, String::UL_AS_IS, 1); - if(head.size()) - head.get_string(0)->split(*columns, 0, "\t", 1, String::UL_AS_IS); + ArrayString head; + data->split(head, &pos_after, "\n", 1, String::UL_AS_IS, 1); + if(head.count()) + head[0]->split(*columns, 0, "\t", 1, String::UL_AS_IS); } - Table& table=*new(pool) Table(pool, &method_name, columns); + TablePtr table(new Table(method_name, columns)); // parse cells - Array rows(pool); - data.split(rows, &pos_after, "\n", 1, String::UL_AS_IS); - Array_iter i(rows); + + ArrayString rows; + data->split(rows, &pos_after, "\n", 1, String::UL_AS_IS); + Array_iterator i(rows); while(i.has_next()) { - Array& row=*new(pool) Array(pool); - const String& string=*i.next_string(); + Table::element_type row(new ArrayString); + StringPtr string=i.next(); // remove comment lines - if(!string.size()) + if(!string->size()) continue; - string.split(row, 0, "\t", 1, String::UL_AS_IS); - table+=&row; + string->split(*row, 0, "\t", 1, String::UL_AS_IS); + *table+=row; } // replace any previous table value - static_cast(r.self)->set_table(table); + GET_SELF(r, VTable).set_table(table); } -static void _load(Request& r, const String& method_name, MethodParams *params) { +static void _load(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); - // filename is last parameter - Value& vfile_name=params->as_no_junction(params->size()-1, - "file name must not be code"); - + StringPtr first_param=params.as_string(0, "file name must be string"); + int filename_param_index=0; + bool nameless=*first_param=="nameless"; + if(nameless) + filename_param_index++; + int options_param_index=filename_param_index+1; + // loading text - char *data=file_read_text(pool, r.absolute(vfile_name.as_string())); + char *data=file_read_text(pool, r.charsets.source(), + r.absolute(params.as_string(filename_param_index, "file name must be string")), + true, + options_param_indexget_hash(method_name):0 + ); // parse columns - Array *columns; + Table::columns_type columns; #ifndef NO_STRING_ORIGIN - const Origin& origin=method_name.origin(); - const char *file=origin.file; + const String_fragment::Origin& origin=method_name->origin(); + const char* file=origin.file; uint line=origin.line; #endif - if(params->size()==2) { - columns=0; // nameless + if(nameless) { + columns=Table::columns_type(0); // nameless } else { - columns=new(pool) Array(pool); + columns=Table::columns_type(new ArrayString); while(char *row_chars=getrow(&data)) { // remove empty&comment lines if(!*row_chars || *row_chars == '#') continue; do { - String *name=new(pool) String(pool); + StringPtr name(new String); name->APPEND_TAINTED(lsplit(&row_chars, '\t'), 0, file, line++); *columns+=name; } while(row_chars); @@ -114,50 +175,49 @@ static void _load(Request& r, const Stri } // parse cells - Table& table=*new(pool) Table(pool, &method_name, columns); + TablePtr table(new Table(method_name, columns)); char *row_chars; while(row_chars=getrow(&data)) { // remove empty&comment lines if(!*row_chars || *row_chars == '#') continue; - Array *row=new(pool) Array(pool); + Table::element_type row(new ArrayString); while(char *cell_chars=lsplit(&row_chars, '\t')) { - String *cell=new(pool) String(pool); + StringPtr cell(new String); cell->APPEND_TAINTED(cell_chars, 0, file, line); *row+=cell; } #ifndef NO_STRING_ORIGIN line++; #endif - table+=row; + *table+=row; }; // replace any previous table value - static_cast(r.self)->set_table(table); + GET_SELF(r, VTable).set_table(table); } /// @todo "x\nx" "xxx""xx" -static void _save(Request& r, const String& method_name, MethodParams *params) { +static void _save(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); - Value& vfile_name=params->as_no_junction(params->size()-1, + ValuePtr vfile_name=params.as_no_junction(params.count()-1, "file name must not be code"); - Table& table=static_cast(r.self)->table(); + Table& table=GET_SELF(r, VTable).table(method_name); bool do_append=false; - String sdata(pool); - if(params->size()==1) { // named output + String sdata; + if(params.count()==1) { // named output // write out names line if(table.columns()) { // named table - Array_iter i(*table.columns()); + Array_iterator i(*table.columns()); while(i.has_next()) { - sdata.append(*i.next_string(), //*static_cast(table.columns()->quick_get(column)), - String::UL_TABLE); + sdata.append(*i.next(), String::UL_TABLE); if(i.has_next()) sdata.APPEND_CONST("\t"); } } else { // nameless table - if(int lsize=table.size()?static_cast(table.get(0))->size():0) + if(int lsize=table.count()?table[0]->count():0) for(int column=0; columnas_string(0, "mode must be string"); - if(mode=="append") + StringPtr mode=params.as_string(0, "mode must be string"); + if(*mode=="append") do_append=true; - else if(mode=="nameless") + else if(*mode=="nameless") /*ok, already skipped names output*/; else throw Exception("parser.runtime", - &mode, + mode, "unknown mode, must be 'append'"); } // data lines - Array_iter i(table); + Array_iterator i(table); while(i.has_next()) { - Array_iter c(*static_cast(i.next())); + Array_iterator c(*i.next()); while(c.has_next()) { - sdata.append(*c.next_string(), //*static_cast(row->quick_get(column)), - String::UL_TABLE); + if(StringPtr s=c.next()) + sdata.append(*s, String::UL_TABLE); if(c.has_next()) sdata.APPEND_CONST("\t"); } @@ -193,137 +253,183 @@ static void _save(Request& r, const Stri } // write - file_write(r.absolute(vfile_name.as_string()), + file_write(r.absolute(vfile_name->as_string(&pool)), sdata.cstr(), sdata.size(), true, do_append); } -static void _count(Request& r, const String& method_name, MethodParams *) { - Pool& pool=r.pool(); - int result=static_cast(r.self)->table().size(); - r.write_no_lang(*new(pool) VInt(pool, result)); +static void _count(Request& r, StringPtr method_name, MethodParams& ) { + int result=GET_SELF(r, VTable).table(method_name).count(); + r.write_no_lang(ValuePtr(new VInt(result))); } -static void _line(Request& r, const String& method_name, MethodParams *) { - Pool& pool=r.pool(); - int result=1+static_cast(r.self)->table().current(); - r.write_no_lang(*new(pool) VInt(pool, result)); +static void _line(Request& r, StringPtr method_name, MethodParams& ) { + int result=1+GET_SELF(r, VTable).table(method_name).current(); + r.write_no_lang(ValuePtr(new VInt(result))); } -static void _offset(Request& r, const String& method_name, MethodParams *params) { +static void _offset(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); - Table& table=static_cast(r.self)->table(); - if(params->size()) { + Table& table=GET_SELF(r, VTable).table(method_name); + if(params.count()) { bool absolute=false; - if(params->size()>1) { - const String& whence=params->as_string(0, "whence must be string"); - if(whence=="cur") + if(params.count()>1) { + StringPtr whence=params.as_string(0, "whence must be string"); + if(*whence=="cur") absolute=false; - else if(whence=="set") + else if(*whence=="set") absolute=true; else throw Exception("parser.runtime", - &whence, + whence, "is invalid whence, valid are 'cur' or 'set'"); - } + } - Value& offset_expr=params->as_junction(params->size()-1, "offset must be expression"); - table.offset(absolute, r.process_to_value(offset_expr).as_int()); + ValuePtr offset_expr=params.as_junction(params.count()-1, "offset must be expression"); + table.offset(absolute, r.process_to_value(offset_expr)->as_int()); } else - r.write_no_lang(*new(pool) VInt(pool, table.current())); + r.write_no_lang(ValuePtr(new VInt(table.current()))); } -static void _menu(Request& r, const String& method_name, MethodParams *params) { - Value& body_code=params->as_junction(0, "body must be code"); +static void _menu(Request& r, StringPtr method_name, MethodParams& params) { + ValuePtr body_code=params.as_junction(0, "body must be code"); - Value *delim_maybe_code=params->size()>1?¶ms->get(1):0; + ValuePtr delim_maybe_code=params.count()>1?params[1]:ValuePtr(0); - Table& table=static_cast(r.self)->table(); + Table& table=GET_SELF(r, VTable).table(method_name); bool need_delim=false; int saved_current=table.current(); - int size=table.size(); + int size=table.count(); for(int row=0; rowsize()) // need delim & iteration produced string? - r.write_pass_lang(r.process(*delim_maybe_code)); + StringOrValue sv_processed=r.process(body_code); + StringPtr s_processed=sv_processed.get_string(); + if(delim_maybe_code && s_processed && s_processed->size()) { // delimiter set and we have body + if(need_delim) // need delim & iteration produced string? + r.write_pass_lang(r.process(delim_maybe_code)); need_delim=true; } - r.write_pass_lang(processed_body); + r.write_pass_lang(sv_processed); } table.set_current(saved_current); } #ifndef DOXYGEN struct Row_info { + Request *r; Table *table; + ValuePtr key_code; int key_field; - Array *value_fields; - Hash *hash; + Array* value_fields; + HashStringValue* hash; + bool distinct; + int row; }; #endif -static void table_row_to_hash(Array::Item *value, void *info) { - Array& row=*static_cast(value); - Row_info& ri=*static_cast(info); - Pool& pool=ri.table->pool(); - - if(ri.key_fieldsize(); i++) { - int value_field=ri.value_fields->get_int(i); - if(value_fieldcolumns()->get_string(value_field), - new(pool) VString(*row.get_string(value_field))); - } +static void table_row_to_hash(Table::element_type row, Row_info *info) { + Pool& pool=info->r->pool(); + + StringPtr key; + if(info->key_code) { + info->table->set_current(info->row++); // change context row + StringOrValue sv_processed=info->r->process(info->key_code); + key=sv_processed.as_string(&pool); + } else + key=info->key_fieldcount()?row->get(info->key_field):StringPtr(0); + + if(!key) + return; // ignore rows without key [too-short-record_array if-indexed] - ri.hash->put(*row.get_string(ri.key_field), &result); + VHashPtr vhash(new VHash); + HashStringValue& hash=vhash->hash(); + for(int i=0; ivalue_fields->count(); i++) { + int value_field=info->value_fields->get(i); + if(value_fieldcount()) + hash.put( + info->table->columns()->get(value_field), + ValuePtr(new VString(row->get(value_field)))); } + + if(info->hash->put_dont_replace(key, vhash)) // put. existed? + if(!info->distinct) + throw Exception("parser.runtime", + key, + "duplicate key"); } -static void _hash(Request& r, const String& method_name, MethodParams *params) { +static void _hash(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); - Table& self_table=static_cast(r.self)->table(); - Value& result=*new(pool) VHash(pool); - if(const Array *columns=self_table.columns()) - if(columns->size()>1) { - const String& key_field_name=params->as_no_junction(0, - "key field name must not be code").as_string(); - int key_field=self_table.column_name2index(key_field_name, true); - - Array value_fields(pool); - if(params->size()>1) { - Value& value_fields_param=params->as_no_junction(1, "value field(s) must not be code"); - if(value_fields_param.is_string()) { - value_fields+=self_table.column_name2index(value_fields_param.as_string(), true); - } else if(Table *value_fields_table=value_fields_param.get_table()) { - for(int i=0; isize(); i++) { - const String& value_field_name= - *static_cast(value_fields_table->get(i))->get_string(0); + Table& self_table=GET_SELF(r, VTable).table(method_name); + VHashPtr result(new VHash); + if(Table::columns_type columns=self_table.columns()) + if(columns->count()>0) { + bool distinct=false; + 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(method_name)) { + --param_index; + int valid_options=0; + if(ValuePtr vdistinct=options->get(sql_distinct_name)) { + valid_options++; + distinct=r.process_to_value(vdistinct)->as_bool(); + } + if(valid_options!=options->count()) + throw Exception("parser.runtime", + method_name, + "called with invalid option"); + } + } + if(param_index==2) // bad options param type + throw Exception("parser.runtime", + method_name, + "options must be hash"); + + Array value_fields; + if(param_index>0) { + ValuePtr value_fields_param=params.as_no_junction(param_index, "value field(s) must not be code"); + if(value_fields_param->is_string()) { + value_fields+=self_table.column_name2index( + value_fields_param->as_string(&pool), true); + } else if(Table* value_fields_table=value_fields_param->get_table()) { + for(int i=0; icount(); i++) { + StringPtr value_field_name= + value_fields_table->get(i)->get(0); value_fields+=self_table.column_name2index(value_field_name, true); } } else throw Exception("parser.runtime", - &method_name, + method_name, "value field(s) must be string or self_table" ); } else { // by all columns, including key - for(int i=0; isize(); i++) + for(int i=0; icount(); i++) value_fields+=i; } - // integers: key_field & value_fields - Row_info row_info={&self_table, key_field, &value_fields, result.get_hash(0)}; - self_table.for_each(table_row_to_hash, &row_info); + + { + Row_info info; + info.r=&r; + info.table=&self_table; + ValuePtr key_param=params[0]; + info.key_code=key_param->get_junction()?key_param:ValuePtr(0); + info.key_field=info.key_code?-1 + :self_table.column_name2index(key_param->as_string(&pool), true); + info.value_fields=&value_fields; + info.hash=&result->hash(); + info.distinct=distinct; + + int saved_current=self_table.current(); + self_table.for_each(table_row_to_hash, &info); + self_table.set_current(saved_current); + } } r.write_no_lang(result); } #ifndef DOXYGEN struct Table_seq_item { - Array *row; + Table::element_type row; union { char *c_str; double d; @@ -346,240 +452,271 @@ static int sort_cmp_double(const void *a else return 0; } -static void _sort(Request& r, const String& method_name, MethodParams *params) { - Pool& pool=r.pool(); - Value& key_maker=params->as_junction(0, "key-maker must be code"); +static void _sort(Request& r, StringPtr method_name, MethodParams& params) { + Pool local_pool; + ValuePtr key_maker=params.as_junction(0, "key-maker must be code"); - bool reverse=params->size()>1/*..[desc|asc|]*/? - reverse=params->as_no_junction(1, "order must not be code").as_string()=="desc": + bool reverse=params.count()>1/*..[desc|asc|]*/? + reverse=*params.as_no_junction(1, "order must not be code")->as_string(&local_pool)=="desc": false; // default=asc - Table& old_table=static_cast(r.self)->table(); - Table& new_table=*new(pool) Table(pool, &method_name, old_table.columns()); + Table& old_table=GET_SELF(r, VTable).table(method_name); + TablePtr new_table(new Table(method_name, old_table.columns())); - Table_seq_item *seq=(Table_seq_item *)pool.malloc(sizeof(Table_seq_item)*old_table.size()); + smart_ptr seq(new Table_seq_item[old_table.count()]); int i; // calculate key values bool key_values_are_strings=true; - // save 'current' - int saved_current=old_table.current(); - for(i=0; ias_expr_result(true/*return string as-is*/); if(i==0) // determining key values type by first one - key_values_are_strings=value.is_string(); + key_values_are_strings=value->is_string(); if(key_values_are_strings) - seq[i].value.c_str=value.as_string().cstr(); + seq[i].value.c_str=value->as_string(&local_pool)->cstr(local_pool); else - seq[i].value.d=value.as_double(); + seq[i].value.d=value->as_double(); } - // restore 'current' - old_table.set_current(saved_current); // sort keys - _qsort(seq, old_table.size(), sizeof(Table_seq_item), + _qsort(seq, old_table.count(), sizeof(Table_seq_item), key_values_are_strings?sort_cmp_string:sort_cmp_double); // reorder table as they require in 'seq' - for(i=0; i(r.self)->set_table(new_table); + GET_SELF(r, VTable).set_table(new_table); } -static bool _locate_expression(Request& r, const String& method_name, MethodParams *params) { - if(params->size()>1) +static bool _locate_expression(Request& r, StringPtr method_name, MethodParams& params) { + if(params.count()>1) throw Exception("parser.runtime", - &method_name, + method_name, "locate by expression has only one parameter - expression"); - Value& expression_code=params->as_junction(0, "must be expression"); + ValuePtr expression_code=params.as_junction(0, "must be expression"); - Table& table=static_cast(r.self)->table(); + Table& table=GET_SELF(r, VTable).table(method_name); int saved_current=table.current(); - int size=table.size(); + int size=table.count(); for(int row=0; rowas_bool()) return true; } table.set_current(saved_current); return false; } -static bool _locate_name_value(Request& r, const String& method_name, MethodParams *params) { - if(params->size()>2) +static bool _locate_name_value(Request& r, StringPtr method_name, MethodParams& params) { + if(params.count()>2) throw Exception("parser.runtime", - &method_name, + method_name, "locate by name and value has only two parameters - name and value"); - Table& table=static_cast(r.self)->table(); + Table& table=GET_SELF(r, VTable).table(method_name); return table.locate( - params->as_string(0, "column name must be string"), - params->as_string(1, "value must be string") + params.as_string(0, "column name must be string"), + params.as_string(1, "value must be string") ); } -static void _locate(Request& r, const String& method_name, MethodParams *params) { +static void _locate(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); - bool result=params->get(0).get_junction()? + bool result=params[0]->get_junction()? _locate_expression(r, method_name, params) : _locate_name_value(r, method_name, params); - r.write_no_lang(*new(pool) VBool(pool, result)); + r.write_no_lang(ValuePtr(new VBool(result))); } -static void _flip(Request& r, const String& method_name, MethodParams *params) { +static void _flip(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); - Table& old_table=static_cast(r.self)->table(); - Table& new_table=*new(pool) Table(pool, &method_name, 0/*nameless*/); - if(old_table.size()) - if(int old_cols=old_table.at(0).size()) + Table& old_table=GET_SELF(r, VTable).table(method_name); + TablePtr new_table(new Table(method_name, old_table.columns())); + if(old_table.count()) + if(int old_cols=old_table[0]->count()) for(int column=0; columncount()?old_row->get(column):StringPtr(new String); } - new_table+=&new_row; + *new_table+=new_row; } - r.write_no_lang(*new(pool) VTable(pool, &new_table)); + r.write_no_lang(ValuePtr(new VTable(new_table))); } -static void _append(Request& r, const String& method_name, MethodParams *params) { +static void _append(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); // data Temp_lang temp_lang(r, String::UL_PASS_APPENDED); - const String& string= - r.process_to_string(params->as_junction(0, "body must be code")); + StringPtr string=r.process_to_string(params.as_junction(0, "body must be code")); // parse cells - Array& row=*new(pool) Array(pool); - string.split(row, 0, "\t", 1, String::UL_AS_IS); + ArrayStringPtr row(new ArrayString); + string->split(*row, 0, "\t", 1, String::UL_AS_IS); - static_cast(r.self)->table()+=&row; + GET_SELF(r, VTable).table(method_name)+=row; } -static void _join(Request& r, const String& method_name, MethodParams *params) { +static void _join(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); - Table *maybe_src=params->as_no_junction(0, "table ref must not be code").get_table(); + Table* maybe_src=params.as_no_junction(0, "table ref must not be code")->get_table(); if(!maybe_src) throw Exception("parser.runtime", - &method_name, + method_name, "source is not a table"); Table& src=*maybe_src; - Table& dest=static_cast(r.self)->table(); + Table& dest=GET_SELF(r, VTable).table(method_name); if(&src == &dest) throw Exception("parser.runtime", - &method_name, + method_name, "source and destination are same table"); - if(const Array *dest_columns=dest.columns()) { // dest is named + int offset, limit; + get_copy_options(r, method_name, params, 1, src, + offset, limit); + + if(Table::columns_type dest_columns=dest.columns()) { // dest is named int saved_src_current=src.current(); - for(int src_row=0; src_rowm) + limit=m; + int end=offset+limit; + for(int src_row=offset; src_rowsize(); dest_column++) { - const String *src_item=src.item(*dest_columns->get_string(dest_column)); - dest_row+=src_item?src_item:new(pool) String(pool); + Table::element_type dest_row(new ArrayString(src.count())); + for(int dest_column=0; dest_columncount(); dest_column++) { + StringPtr src_item=src.item(dest_columns->get(dest_column)); + *dest_row+=src_item?src_item:StringPtr(new String); } - dest+=&dest_row; + dest+=dest_row; } src.set_current(saved_src_current); } else { // dest is nameless - for(int src_row=0; src_rowAPPEND_TAINTED( - (const char *)ptr, size, - statement_cstr, 0); - columns+=column; - } - void before_rows() { - table=new(pool) Table(pool, &method_name, &columns); - } - void add_row() { - (*table)+=(row=new(pool) Array(pool)); - } - void add_row_cell(void *ptr, size_t size) { - String *cell=new(pool) String(pool); - if(size) - cell->APPEND_TAINTED( - (const char *)ptr, size, - statement_cstr, table->size()-1); - (*row)+=cell; - } + columns(new ArrayString) + {} -private: - Pool& pool; - const String& method_name; - const String& statement_string; const char *statement_cstr; - Array& columns; - Array *row; -public: - Table *table; + bool add_column(SQL_Error& error, void *ptr, size_t size) { + try { + StringPtr column(new String); + column->APPEND_TAINTED( + (const char* )ptr, size, + statement_cstr, 0); + *columns+=column; + return false; + } catch(...) { + error=SQL_Error("exception occured in Table_sql_event_handlers::add_column"); + return true; + } + } + bool before_rows(SQL_Error& error) { + try { + table=TablePtr(new Table( method_name, columns)); + return false; + } catch(...) { + error=SQL_Error("exception occured in Table_sql_event_handlers::before_rows"); + return true; + } + } + bool add_row(SQL_Error& error) { + try { + *table+=(ArrayStringPtr(row=new ArrayString)); + return false; + } catch(...) { + error=SQL_Error("exception occured in Table_sql_event_handlers::add_row"); + return true; + } + } + bool add_row_cell(SQL_Error& error, void *ptr, size_t size) { + try { + StringPtr cell(new String); + if(size) + cell->APPEND_TAINTED( + (const char* )ptr, size, + statement_cstr, table->count()-1); + *row+=cell; + return false; + } catch(...) { + error=SQL_Error("exception occured in Table_sql_event_handlers::add_row_cell"); + return true; + } + } }; #endif -static void _sql(Request& r, const String& method_name, MethodParams *params) { +static void _sql(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); - Value& statement=params->as_junction(0, "statement must be code"); + ValuePtr statement=params.as_junction(0, "statement must be code"); ulong limit=0; ulong offset=0; - if(params->size()>1) { - Value& voptions=params->as_no_junction(1, "options must be hash, not code"); - if(voptions.is_defined()) - if(Hash *options=voptions.get_hash(&method_name)) { - if(Value *vlimit=(Value *)options->get(*sql_limit_name)) - limit=(ulong)r.process_to_value(*vlimit).as_double(); - if(Value *voffset=(Value *)options->get(*sql_offset_name)) - offset=(ulong)r.process_to_value(*voffset).as_double(); + if(params.count()>1) { + ValuePtr voptions=params.as_no_junction(1, "options must be hash, not code"); + if(!voptions->is_string()) + if(HashStringValue* options=voptions->get_hash(method_name)) { + int valid_options=0; + if(ValuePtr vlimit=options->get(sql_limit_name)) { + valid_options++; + limit=(ulong)r.process_to_value(vlimit)->as_double(); + } + if(ValuePtr voffset=options->get(sql_offset_name)) { + valid_options++; + offset=(ulong)r.process_to_value(voffset)->as_double(); + } + if(valid_options!=options->count()) + throw Exception("parser.runtime", + method_name, + "called with invalid option"); } else throw Exception("parser.runtime", - &method_name, + method_name, "options must be hash"); } Temp_lang temp_lang(r, String::UL_SQL); - const String& statement_string=r.process_to_string(statement); - const char *statement_cstr= - statement_string.cstr(String::UL_UNSPECIFIED, r.connection(&method_name)); + StringPtr statement_string=r.process_to_string(statement); + const char* statement_cstr= + statement_string->cstr(pool, String::UL_UNSPECIFIED, r.connection(method_name)); Table_sql_event_handlers handlers(pool, method_name, statement_string, statement_cstr); - try { #ifdef RESOURCES_DEBUG struct timeval mt[2]; //measure:before gettimeofday(&mt[0],NULL); #endif - r.connection(&method_name)->query( - statement_cstr, offset, limit, - handlers); + r.connection(method_name)->query( + statement_cstr, offset, limit, + handlers, + statement_string); #ifdef RESOURCES_DEBUG //measure:after connect @@ -591,72 +728,66 @@ static void _sql(Request& r, const Strin r.sql_request_time+=t[1]-t[0]; #endif - } catch(const Exception& e) { // query problem - // more specific source [were url] - throw Exception("sql.execute", - &statement_string, - "%s", e.comment()); - } - Table *result= + TablePtr result= handlers.table?handlers.table: // query resulted in table? return it - new(pool) Table(pool, &method_name, 0); // query returned no table, fake it + TablePtr(new Table(method_name, Table::columns_type(0))); // query returned no table, fake it // replace any previous table value - static_cast(r.self)->set_table(*result); + GET_SELF(r, VTable).set_table(result); } -static void _columns(Request& r, const String& method_name, MethodParams *) { +static void _columns(Request& r, StringPtr method_name, MethodParams& ) { Pool& pool=r.pool(); - Array& result_columns=*new(pool) Array(pool); - result_columns+=new(pool) String(pool, "column"); - Table& result_table=*new(pool) Table(pool, &method_name, &result_columns); + Table::columns_type result_columns(new ArrayString); + *result_columns+=StringPtr(new String("column")); + TablePtr result_table(new Table(method_name, result_columns)); - Table& source_table=static_cast(r.self)->table(); - if(const Array *source_columns=source_table.columns()) { - Array_iter i(*source_columns); + Table& source_table=GET_SELF(r, VTable).table(method_name); + if(Table::columns_type source_columns=source_table.columns()) { + Array_iterator i(*source_columns); while(i.has_next()) { - Array& result_row=*new(pool) Array(pool); - result_row+=i.next(); - result_table+=&result_row; + Table::element_type result_row(new ArrayString); + *result_row+=i.next(); + *result_table+=result_row; } } - r.write_no_lang(*new(pool) VTable(pool, &result_table)); + r.write_no_lang(ValuePtr(new VTable(result_table))); } -static void _select(Request& r, const String& method_name, MethodParams *params) { +static void _select(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); - Value& vcondition=params->as_junction(0, "condition must be expression"); + ValuePtr vcondition=params.as_junction(0, "condition must be expression"); - Table& source_table=static_cast(r.self)->table(); - Table& result_table=*new(pool) Table(pool, + Table& source_table=GET_SELF(r, VTable).table(method_name); + TablePtr result_table(new Table( source_table.origin_string(), source_table.columns() - ); + )); int saved_current=source_table.current(); - int size=source_table.size(); + int size=source_table.count(); for(int row=0; rowas_bool(); if(condition) // ...condition is true= - result_table+=&source_table.at(row); // =green light to go to result + *result_table+=source_table[row]; // =green light to go to result } source_table.set_current(saved_current); - r.write_no_lang(*new(pool) VTable(pool, &result_table)); + r.write_no_lang(ValuePtr(new VTable(result_table))); } // constructor -MTable::MTable(Pool& apool) : Methoded(apool, "table") { +MTable::MTable(): Methoded("table") { // ^table::create{data} // ^table::create[nameless]{data} // ^table::create[table] @@ -666,7 +797,7 @@ MTable::MTable(Pool& apool) : Methoded(a // ^table::load[file] // ^table::load[nameless;file] - add_native_method("load", Method::CT_DYNAMIC, _load, 1, 2); + add_native_method("load", Method::CT_DYNAMIC, _load, 1, 3); // ^table.save[file] // ^table.save[nameless;file] @@ -689,7 +820,7 @@ MTable::MTable(Pool& apool) : Methoded(a // ^table:hash[key field name] // ^table:hash[key field name][value field name(s) string/table] - add_native_method("hash", Method::CT_DYNAMIC, _hash, 1, 2); + add_native_method("hash", Method::CT_DYNAMIC, _hash, 1, 3); // ^table.sort{string-key-maker} ^table.sort{string-key-maker}[desc|asc] // ^table.sort(numeric-key-maker) ^table.sort(numeric-key-maker)[desc|asc] @@ -704,8 +835,8 @@ MTable::MTable(Pool& apool) : Methoded(a // ^table.append{r{tab}e{tab}c{tab}o{tab}r{tab}d} add_native_method("append", Method::CT_DYNAMIC, _append, 1, 1); - // ^table.join[table] - add_native_method("join", Method::CT_DYNAMIC, _join, 1, 1); + // ^table.join[table][$.limit(10) $.offset(1) $.offset[cur] ] + add_native_method("join", Method::CT_DYNAMIC, _join, 1, 2); // ^table:sql[query] @@ -718,13 +849,3 @@ MTable::MTable(Pool& apool) : Methoded(a // ^table.select(expression) = table add_native_method("select", Method::CT_DYNAMIC, _select, 1, 1); } - -// global variable - -Methoded *table_class; - -// creator - -Methoded *MTable_create(Pool& pool) { - return table_class=new(pool) MTable(pool); -}