--- parser3/src/classes/table.C 2003/02/04 15:15:02 1.172.2.5 +++ parser3/src/classes/table.C 2003/04/11 10:39:24 1.174 @@ -1,15 +1,13 @@ /** @file Parser: @b table parser class. - Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com) + Copyright (c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com) Author: Alexandr Petrosian (http://paf.design.ru) */ -static const char* IDENT_TABLE_C="$Date: 2003/02/04 15:15:02 $"; +static const char* IDENT_TABLE_C="$Date: 2003/04/11 10:39:24 $"; #include "classes.h" -#include "pa_vmethod_frame.h" - #include "pa_common.h" #include "pa_request.h" #include "pa_vtable.h" @@ -21,7 +19,7 @@ static const char* IDENT_TABLE_C="$Date: class MTable : public Methoded { public: // VStateless_class - ValuePtr create_new_value() { return ValuePtr(new VTable()); } + Value *create_new_value(Pool& pool) { return new(pool) VTable(pool); } public: MTable(Pool& pool); @@ -32,16 +30,16 @@ public: // Methoded // methods -static void get_copy_options(Request& r, StringPtr method_name, MethodParams& params, int param_index, +static void get_copy_options(Request& r, const String& method_name, MethodParams *params, int param_index, const Table& source, int& offset, int& limit) { offset=0; limit=0; - if(params.count()<=param_index) + if(params->size()<=param_index) return; - Value& voptions=params.as_no_junction(param_index, "options must be hash, not code"); + Value& voptions=params->as_no_junction(param_index, "options must be hash, not code"); if(!voptions.is_string()) { if(Hash *options=voptions.get_hash(&method_name)) { int valid_options=0; @@ -64,21 +62,21 @@ static void get_copy_options(Request& r, } if(valid_options!=options->size()) throw Exception("parser.runtime", - method_name, + &method_name, "called with invalid option"); } else throw Exception("parser.runtime", - method_name, + &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) { +static void _create(Request& r, const String& method_name, MethodParams *params) { Pool& pool=r.pool(); // clone/copy part? - if(const Table *source=params.get(0).get_table()) { + if(const Table *source=params->get(0).get_table()) { int offset, limit; get_copy_options(r, method_name, params, 1, *source, offset, limit); @@ -89,12 +87,12 @@ static void _create(Request& r, StringPt // data is last parameter Temp_lang temp_lang(r, String::UL_PASS_APPENDED); const String& data= - r.process_to_string(params.as_junction(params.count()-1, "body must be code")); + r.process_to_string(params->as_junction(params->size()-1, "body must be code")); size_t pos_after=0; // parse columns Array *columns; - if(params.count()==2) { + if(params->size()==2) { columns=0; } else { columns=new(pool) Array(pool); @@ -105,7 +103,7 @@ static void _create(Request& r, StringPt head.get_string(0)->split(*columns, 0, "\t", 1, String::UL_AS_IS); } - Table& table=*new(pool) Table(pool, method_name, columns); + Table& table=*new(pool) Table(pool, &method_name, columns); // parse cells Array rows(pool); data.split(rows, &pos_after, "\n", 1, String::UL_AS_IS); @@ -125,9 +123,9 @@ static void _create(Request& r, StringPt static_cast(r.get_self())->set_table(table); } -static void _load(Request& r, StringPtr method_name, MethodParams& params) { +static void _load(Request& r, const String& method_name, MethodParams *params) { Pool& pool=r.pool(); - const String& first_param=params.as_string(0, "file name must be string"); + const String& first_param=params->as_string(0, "file name must be string"); int filename_param_index=0; bool nameless=first_param=="nameless"; if(nameless) @@ -136,16 +134,16 @@ static void _load(Request& r, StringPtr // loading text char *data=file_read_text(pool, - r.absolute(params.as_string(filename_param_index, "file name must be string")), + r.absolute(params->as_string(filename_param_index, "file name must be string")), true, - options_param_indexsize()?params->as_no_junction(options_param_index, "additional params must be hash").get_hash(&method_name):0 ); // parse columns Array *columns; #ifndef NO_STRING_ORIGIN - const Origin& origin=method_name->origin(); - const char* file=origin.file; + const Origin& origin=method_name.origin(); + const char *file=origin.file; uint line=origin.line; #endif if(nameless) { @@ -168,7 +166,7 @@ static void _load(Request& r, StringPtr } // parse cells - Table& table=*new(pool) Table(pool, method_name, columns); + Table& table=*new(pool) Table(pool, &method_name, columns); char *row_chars; while(row_chars=getrow(&data)) { // remove empty&comment lines @@ -191,16 +189,16 @@ static void _load(Request& r, StringPtr } /// @todo "x\nx" "xxx""xx" -static void _save(Request& r, StringPtr method_name, MethodParams& params) { +static void _save(Request& r, const String& method_name, MethodParams *params) { Pool& pool=r.pool(); - Value& vfile_name=params.as_no_junction(params.count()-1, + Value& vfile_name=params->as_no_junction(params->size()-1, "file name must not be code"); Table& table=static_cast(r.get_self())->table(&method_name); bool do_append=false; String sdata(pool); - if(params.count()==1) { // named output + if(params->size()==1) { // named output // write out names line if(table.columns()) { // named table Array_iter i(*table.columns()); @@ -222,7 +220,7 @@ static void _save(Request& r, StringPtr } sdata.APPEND_CONST("\n"); } else { // mode specified - const String& mode=params.as_string(0, "mode must be string"); + const String& mode=params->as_string(0, "mode must be string"); if(mode=="append") do_append=true; else if(mode=="nameless") @@ -252,25 +250,25 @@ static void _save(Request& r, StringPtr sdata.cstr(), sdata.size(), true, do_append); } -static void _count(Request& r, StringPtr method_name, MethodParams& ) { +static void _count(Request& r, const String& method_name, MethodParams *) { Pool& pool=r.pool(); int result=static_cast(r.get_self())->table(&method_name).size(); r.write_no_lang(*new(pool) VInt(pool, result)); } -static void _line(Request& r, StringPtr method_name, MethodParams& ) { +static void _line(Request& r, const String& method_name, MethodParams *) { Pool& pool=r.pool(); int result=1+static_cast(r.get_self())->table(&method_name).current(); r.write_no_lang(*new(pool) VInt(pool, result)); } -static void _offset(Request& r, StringPtr method_name, MethodParams& params) { +static void _offset(Request& r, const String& method_name, MethodParams *params) { Pool& pool=r.pool(); Table& table=static_cast(r.get_self())->table(&method_name); - if(params.count()) { + if(params->size()) { bool absolute=false; - if(params.count()>1) { - const String& whence=params.as_string(0, "whence must be string"); + if(params->size()>1) { + const String& whence=params->as_string(0, "whence must be string"); if(whence=="cur") absolute=false; else if(whence=="set") @@ -281,16 +279,16 @@ static void _offset(Request& r, StringPt "is invalid whence, valid are 'cur' or 'set'"); } - Value& offset_expr=params.as_junction(params.count()-1, "offset must be expression"); + Value& offset_expr=params->as_junction(params->size()-1, "offset must be expression"); table.offset(absolute, r.process_to_value(offset_expr).as_int()); } else r.write_no_lang(*new(pool) VInt(pool, table.current())); } -static void _menu(Request& r, StringPtr method_name, MethodParams& params) { - Value& body_code=params.as_junction(0, "body must be code"); +static void _menu(Request& r, const String& method_name, MethodParams *params) { + Value& body_code=params->as_junction(0, "body must be code"); - Value *delim_maybe_code=params.count()>1?¶ms.get(1):0; + Value *delim_maybe_code=params->size()>1?¶ms->get(1):0; Table& table=static_cast(r.get_self())->table(&method_name); bool need_delim=false; @@ -312,6 +310,7 @@ static void _menu(Request& r, StringPtr } #ifndef DOXYGEN +enum Table2hash_distint { D_ILLEGAL, D_FIRST, D_TABLES }; struct Row_info { Request *r; Table *table; @@ -319,7 +318,7 @@ struct Row_info { int key_field; Array *value_fields; Hash *hash; - bool distinct; + Table2hash_distint distinct; int row; }; #endif @@ -339,53 +338,92 @@ static void table_row_to_hash(Array::Ite if(!key) return; // ignore rows without key [too-short-record_array if-indexed] - VHash& result=*new(pool) VHash(pool); - Hash& hash=*result.get_hash(0); - for(int i=0; isize(); 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))); + switch(ri.distinct) { + case D_ILLEGAL: case D_FIRST: + { + VHash& result=*new(pool) VHash(pool); + Hash& hash=*result.get_hash(0); + for(int i=0; isize(); 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))); + } + + if(ri.hash->put_dont_replace(*key, &result)) // put. existed? + if(ri.distinct==D_ILLEGAL) + throw Exception("parser.runtime", + key, + "duplicate key"); + } + break; + case D_TABLES: + { + VTable* vtable=(VTable*)ri.hash->get(*key); // put. table existed? + Table* table; + if(vtable) + table=vtable->get_table(); + else { + // no? creating table of same structure as source + table=new(pool) Table(pool, *ri.table, 0, -1 /*no rows, just structure*/); + ri.hash->put(*key, new(pool) VTable(pool, table)); + } + *table+=&row; + } + break; + default: + throw Exception(0, + 0, + "invalid distinct code (#%d), ri.distinct"); } - if(ri.hash->put_dont_replace(*key, &result)) // put. existed? - if(!ri.distinct) - throw Exception("parser.runtime", - key, - "duplicate key"); } -static void _hash(Request& r, StringPtr method_name, MethodParams& params) { +static void _hash(Request& r, const String& method_name, MethodParams *params) { Pool& pool=r.pool(); Table& self_table=static_cast(r.get_self())->table(&method_name); Value& result=*new(pool) VHash(pool); if(const Array *columns=self_table.columns()) if(columns->size()>0) { - bool distinct=false; - int param_index=params.count()-1; + Table2hash_distint distinct=D_ILLEGAL; + int param_index=params->size()-1; if(param_index>0) { if(Hash *options= - params.as_no_junction(param_index, "param must not be code").get_hash(0)) { + params->as_no_junction(param_index, "param must not be code").get_hash(0)) { --param_index; int valid_options=0; - if(Value *vdistinct=(Value *)options->get(*sql_distinct_name)) { + if(Value *vdistinct_code=(Value *)options->get(*sql_distinct_name)) { valid_options++; - distinct=r.process_to_value(*vdistinct).as_bool(); + Value& vdistinct_value=r.process_to_value(*vdistinct_code); + if(vdistinct_value.is_string()) { + const String& sdistinct=*vdistinct_value.get_string(); + if(sdistinct=="tables") + distinct=D_TABLES; + else + throw Exception("parser.runtime", + &sdistinct, + "must be 'tables' or true/false"); + } else + distinct=vdistinct_value.as_bool()?D_FIRST:D_ILLEGAL; } if(valid_options!=options->size()) throw Exception("parser.runtime", - method_name, + &method_name, "called with invalid option"); } } if(param_index==2) // bad options param type throw Exception("parser.runtime", - method_name, + &method_name, "options must be hash"); Array value_fields(pool); if(param_index>0) { - Value& value_fields_param=params.as_no_junction(param_index, "value field(s) must not be code"); + if(distinct!=D_ILLEGAL && distinct!=D_FIRST) + throw Exception("parser.runtime", + 0, + "in distinct[tables] mode you may not specify value field(s)"); + Value& 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(), true); } else if(Table *value_fields_table=value_fields_param.get_table()) { @@ -396,20 +434,23 @@ static void _hash(Request& r, StringPtr } } 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++) - value_fields+=i; + if(!(distinct!=D_ILLEGAL && distinct!=D_FIRST)) + for(int i=0; isize(); i++) + value_fields+=i; } - Value& key_param=params.get(0); + Value& key_param=params->get(0); Value *key_code=key_param.get_junction()?&key_param:0; int key_field=key_code?-1 :self_table.column_name2index(key_param.as_string(), true); - Row_info row_info={&r, &self_table, key_code, key_field, &value_fields, result.get_hash(0), distinct}; + Row_info row_info={&r, &self_table, + key_code, key_field, &value_fields, + result.get_hash(0), distinct}; int saved_current=self_table.current(); self_table.for_each(table_row_to_hash, &row_info); @@ -443,16 +484,19 @@ static int sort_cmp_double(const void *a else return 0; } -static void _sort(Request& r, StringPtr method_name, MethodParams& params) { +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"); + Value& key_maker=params->as_junction(0, "key-maker must be code"); - bool reverse=params.count()>1/*..[desc|asc|]*/? - reverse=params.as_no_junction(1, "order must not be code").as_string()=="desc": + bool reverse=params->size()>1/*..[desc|asc|]*/? + reverse=params->as_no_junction(1, "order must not be code").as_string()=="desc": false; // default=asc Table& old_table=static_cast(r.get_self())->table(&method_name); - Table& new_table=*new(pool) Table(pool, method_name, old_table.columns()); + if(old_table.size()==0) + return; + + Table& new_table=*new(pool) Table(pool, &method_name, old_table.columns()); Table_seq_item *seq=(Table_seq_item *)pool.malloc(sizeof(Table_seq_item)*old_table.size()); int i; @@ -484,13 +528,13 @@ static void _sort(Request& r, StringPtr static_cast(r.get_self())->set_table(new_table); } -static bool _locate_expression(Request& r, StringPtr method_name, MethodParams& params) { - if(params.count()>1) +static bool _locate_expression(Request& r, const String& method_name, MethodParams *params) { + if(params->size()>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"); + Value& expression_code=params->as_junction(0, "must be expression"); Table& table=static_cast(r.get_self())->table(&method_name); int saved_current=table.current(); @@ -504,30 +548,30 @@ static bool _locate_expression(Request& table.set_current(saved_current); return false; } -static bool _locate_name_value(Request& r, StringPtr method_name, MethodParams& params) { - if(params.count()>2) +static bool _locate_name_value(Request& r, const String& method_name, MethodParams *params) { + if(params->size()>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.get_self())->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, StringPtr method_name, MethodParams& params) { +static void _locate(Request& r, const String& method_name, MethodParams *params) { Pool& pool=r.pool(); - bool result=params.get(0).get_junction()? + bool result=params->get(0).get_junction()? _locate_expression(r, method_name, params) : _locate_name_value(r, method_name, params); r.write_no_lang(*new(pool) VBool(pool, result)); } -static void _flip(Request& r, StringPtr method_name, MethodParams& params) { +static void _flip(Request& r, const String& method_name, MethodParams *params) { Pool& pool=r.pool(); Table& old_table=static_cast(r.get_self())->table(&method_name); - Table& new_table=*new(pool) Table(pool, method_name, 0/*nameless*/); + Table& new_table=*new(pool) Table(pool, &method_name, 0/*nameless*/); if(old_table.size()) if(int old_cols=old_table.at(0).size()) for(int column=0; columnas_junction(0, "body must be code")); // parse cells Array& row=*new(pool) Array(pool); @@ -556,20 +600,20 @@ static void _append(Request& r, StringPt static_cast(r.get_self())->table(&method_name)+=&row; } -static void _join(Request& r, StringPtr method_name, MethodParams& params) { +static void _join(Request& r, const String& 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.get_self())->table(&method_name); if(&src == &dest) throw Exception("parser.runtime", - method_name, + &method_name, "source and destination are same table"); int offset, limit; @@ -602,7 +646,7 @@ static void _join(Request& r, StringPtr class Table_sql_event_handlers: public SQL_Driver_query_event_handlers { public: Table_sql_event_handlers(Pool& apool, const String& amethod_name, - const String& astatement_string, const char* astatement_cstr) : + const String& astatement_string, const char *astatement_cstr) : pool(apool), method_name(amethod_name), statement_string(astatement_string), @@ -617,7 +661,7 @@ public: try { String *column=new(pool) String(pool); column->APPEND_TAINTED( - (const char* )ptr, size, + (const char *)ptr, size, statement_cstr, 0); columns+=column; return false; @@ -628,7 +672,7 @@ public: } bool before_rows(SQL_Error& error) { try { - table=new(pool) Table(pool, method_name, &columns); + table=new(pool) Table(pool, &method_name, &columns); return false; } catch(...) { error=SQL_Error("exception occured in Table_sql_event_handlers::before_rows"); @@ -649,7 +693,7 @@ public: String *cell=new(pool) String(pool); if(size) cell->APPEND_TAINTED( - (const char* )ptr, size, + (const char *)ptr, size, statement_cstr, table->size()-1); (*row)+=cell; return false; @@ -662,22 +706,22 @@ public: private: Pool& pool; const String& method_name; - const String& statement_string; const char* statement_cstr; + const String& statement_string; const char *statement_cstr; Array& columns; Array *row; public: Table *table; }; #endif -static void _sql(Request& r, StringPtr method_name, MethodParams& params) { +static void _sql(Request& r, const String& method_name, MethodParams *params) { Pool& pool=r.pool(); - Value& statement=params.as_junction(0, "statement must be code"); + Value& statement=params->as_junction(0, "statement must be code"); ulong limit=0; ulong offset=0; - if(params.count()>1) { - Value& voptions=params.as_no_junction(1, "options must be hash, not code"); + if(params->size()>1) { + Value& voptions=params->as_no_junction(1, "options must be hash, not code"); if(!voptions.is_string()) if(Hash *options=voptions.get_hash(&method_name)) { int valid_options=0; @@ -691,17 +735,17 @@ static void _sql(Request& r, StringPtr m } if(valid_options!=options->size()) throw Exception("parser.runtime", - method_name, + &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= + const char *statement_cstr= statement_string.cstr(String::UL_UNSPECIFIED, r.connection(&method_name)); Table_sql_event_handlers handlers(pool, method_name, statement_string, statement_cstr); @@ -728,18 +772,18 @@ static void _sql(Request& r, StringPtr m Table *result= handlers.table?handlers.table: // query resulted in table? return it - new(pool) Table(pool, method_name, 0); // query returned no table, fake it + new(pool) Table(pool, &method_name, 0); // query returned no table, fake it // replace any previous table value static_cast(r.get_self())->set_table(*result); } -static void _columns(Request& r, StringPtr method_name, MethodParams& ) { +static void _columns(Request& r, const String& 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& result_table=*new(pool) Table(pool, &method_name, &result_columns); Table& source_table=static_cast(r.get_self())->table(&method_name); if(const Array *source_columns=source_table.columns()) { @@ -754,10 +798,10 @@ static void _columns(Request& r, StringP r.write_no_lang(*new(pool) VTable(pool, &result_table)); } -static void _select(Request& r, StringPtr method_name, MethodParams& params) { +static void _select(Request& r, const String& method_name, MethodParams *params) { Pool& pool=r.pool(); - Value& vcondition=params.as_junction(0, "condition must be expression"); + Value& vcondition=params->as_junction(0, "condition must be expression"); Table& source_table=static_cast(r.get_self())->table(&method_name); Table& result_table=*new(pool) Table(pool,