[BACK]Return to table.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/table.C between versions 1.172.2.2 and 1.172.2.3

version 1.172.2.2, 2003/01/31 12:34:27 version 1.172.2.3, 2003/02/04 14:04:46
Line 30  public: // Methoded Line 30  public: // Methoded
   
 // methods  // methods
   
 static void get_copy_options(Request& r, const String& method_name, MethodParams *params, int param_index,  static void get_copy_options(Request& r, StringPtr method_name, MethodParams& params, int param_index,
                                                          const Table& source,                                                           const Table& source,
                                                          int& offset,                                                           int& offset,
                                                          int& limit) {                                                           int& limit) {
         offset=0;          offset=0;
         limit=0;          limit=0;
         if(params->size()<=param_index)          if(params.count()<=param_index)
                 return;                  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(!voptions.is_string()) {
                 if(Hash *options=voptions.get_hash(&method_name)) {                  if(Hash *options=voptions.get_hash(&method_name)) {
                         int valid_options=0;                          int valid_options=0;
Line 73  static void get_copy_options(Request& r, Line 73  static void get_copy_options(Request& r,
                 limit=-1; // thus fixing                  limit=-1; // thus fixing
 }  }
   
 static void _create(Request& r, const String& method_name, MethodParams *params) {  static void _create(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         // clone/copy part?          // clone/copy part?
         if(const Table *source=params->get(0).get_table()) {          if(const Table *source=params.get(0).get_table()) {
                 int offset, limit;                  int offset, limit;
                 get_copy_options(r, method_name, params, 1, *source,                   get_copy_options(r, method_name, params, 1, *source, 
                         offset, limit);                          offset, limit);
Line 87  static void _create(Request& r, const St Line 87  static void _create(Request& r, const St
         // data is last parameter          // data is last parameter
         Temp_lang temp_lang(r, String::UL_PASS_APPENDED);          Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
         const String& data=          const String& data=
                 r.process_to_string(params->as_junction(params->size()-1, "body must be code"));                  r.process_to_string(params.as_junction(params.count()-1, "body must be code"));
   
         size_t pos_after=0;          size_t pos_after=0;
         // parse columns          // parse columns
         Array *columns;          Array *columns;
         if(params->size()==2) {          if(params.count()==2) {
                 columns=0;                  columns=0;
         } else {          } else {
                 columns=new(pool) Array(pool);                  columns=new(pool) Array(pool);
Line 123  static void _create(Request& r, const St Line 123  static void _create(Request& r, const St
         static_cast<VTable *>(r.get_self())->set_table(table);          static_cast<VTable *>(r.get_self())->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();          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;          int filename_param_index=0;
         bool nameless=first_param=="nameless";          bool nameless=first_param=="nameless";
         if(nameless)          if(nameless)
Line 134  static void _load(Request& r, const Stri Line 134  static void _load(Request& r, const Stri
                   
         // loading text          // loading text
         char *data=file_read_text(pool,           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,                  true,
                 options_param_index<params->size()?params->as_no_junction(options_param_index, "additional params must be hash").get_hash(&method_name):0                  options_param_index<params.count()?params.as_no_junction(options_param_index, "additional params must be hash").get_hash(&method_name):0
         );          );
   
         // parse columns          // parse columns
Line 189  static void _load(Request& r, const Stri Line 189  static void _load(Request& r, const Stri
 }  }
   
 /// @todo "x\nx" "xxx""xx"  /// @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();          Pool& pool=r.pool();
         Value& vfile_name=params->as_no_junction(params->size()-1,           Value& vfile_name=params.as_no_junction(params.count()-1, 
                 "file name must not be code");                  "file name must not be code");
   
         Table& table=static_cast<VTable *>(r.get_self())->table(&method_name);          Table& table=static_cast<VTable *>(r.get_self())->table(&method_name);
   
         bool do_append=false;          bool do_append=false;
         String sdata(pool);          String sdata(pool);
         if(params->size()==1) { // named output          if(params.count()==1) { // named output
                 // write out names line                  // write out names line
                 if(table.columns()) { // named table                  if(table.columns()) { // named table
                         Array_iter i(*table.columns());                          Array_iter i(*table.columns());
Line 220  static void _save(Request& r, const Stri Line 220  static void _save(Request& r, const Stri
                 }                  }
                 sdata.APPEND_CONST("\n");                  sdata.APPEND_CONST("\n");
         } else { // mode specified          } 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")                  if(mode=="append")
                         do_append=true;                          do_append=true;
                 else if(mode=="nameless")                  else if(mode=="nameless")
Line 250  static void _save(Request& r, const Stri Line 250  static void _save(Request& r, const Stri
                 sdata.cstr(), sdata.size(), true, do_append);                  sdata.cstr(), sdata.size(), true, do_append);
 }  }
   
 static void _count(Request& r, const String& method_name, MethodParams *) {  static void _count(Request& r, StringPtr method_name, MethodParams& ) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         int result=static_cast<VTable *>(r.get_self())->table(&method_name).size();          int result=static_cast<VTable *>(r.get_self())->table(&method_name).size();
         r.write_no_lang(*new(pool) VInt(pool, result));          r.write_no_lang(*new(pool) VInt(pool, result));
 }  }
   
 static void _line(Request& r, const String& method_name, MethodParams *) {  static void _line(Request& r, StringPtr method_name, MethodParams& ) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         int result=1+static_cast<VTable *>(r.get_self())->table(&method_name).current();          int result=1+static_cast<VTable *>(r.get_self())->table(&method_name).current();
         r.write_no_lang(*new(pool) VInt(pool, result));          r.write_no_lang(*new(pool) VInt(pool, 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();          Pool& pool=r.pool();
         Table& table=static_cast<VTable *>(r.get_self())->table(&method_name);          Table& table=static_cast<VTable *>(r.get_self())->table(&method_name);
         if(params->size()) {          if(params.count()) {
                 bool absolute=false;                  bool absolute=false;
                 if(params->size()>1) {                  if(params.count()>1) {
                     const String& whence=params->as_string(0, "whence must be string");                      const String& whence=params.as_string(0, "whence must be string");
                     if(whence=="cur")                      if(whence=="cur")
                                 absolute=false;                                  absolute=false;
                     else if(whence=="set")                      else if(whence=="set")
Line 279  static void _offset(Request& r, const St Line 279  static void _offset(Request& r, const St
                                         "is invalid whence, valid are 'cur' or 'set'");                                          "is invalid whence, valid are 'cur' or 'set'");
                 }                  }
                                   
                 Value& offset_expr=params->as_junction(params->size()-1, "offset must be expression");                  Value& offset_expr=params.as_junction(params.count()-1, "offset must be expression");
                 table.offset(absolute, r.process_to_value(offset_expr).as_int());                  table.offset(absolute, r.process_to_value(offset_expr).as_int());
         } else          } else
                 r.write_no_lang(*new(pool) VInt(pool, table.current()));                  r.write_no_lang(*new(pool) VInt(pool, table.current()));
 }  }
   
 static void _menu(Request& r, const String& method_name, MethodParams *params) {  static void _menu(Request& r, StringPtr method_name, MethodParams& params) {
         Value& body_code=params->as_junction(0, "body must be code");          Value& body_code=params.as_junction(0, "body must be code");
                   
         Value *delim_maybe_code=params->size()>1?&params->get(1):0;          Value *delim_maybe_code=params.count()>1?&params.get(1):0;
   
         Table& table=static_cast<VTable *>(r.get_self())->table(&method_name);          Table& table=static_cast<VTable *>(r.get_self())->table(&method_name);
         bool need_delim=false;          bool need_delim=false;
Line 353  static void table_row_to_hash(Array::Ite Line 353  static void table_row_to_hash(Array::Ite
                                 key,                                  key,
                                 "duplicate 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();          Pool& pool=r.pool();
         Table& self_table=static_cast<VTable *>(r.get_self())->table(&method_name);          Table& self_table=static_cast<VTable *>(r.get_self())->table(&method_name);
         Value& result=*new(pool) VHash(pool);          Value& result=*new(pool) VHash(pool);
         if(const Array *columns=self_table.columns())          if(const Array *columns=self_table.columns())
                 if(columns->size()>0) {                  if(columns->size()>0) {
                         bool distinct=false;                          bool distinct=false;
                         int param_index=params->size()-1;                          int param_index=params.count()-1;
                         if(param_index>0) {                          if(param_index>0) {
                                 if(Hash *options=                                  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;                                          --param_index;
                                         int valid_options=0;                                          int valid_options=0;
                                         if(Value *vdistinct=(Value *)options->get(*sql_distinct_name)) {                                          if(Value *vdistinct=(Value *)options->get(*sql_distinct_name)) {
Line 383  static void _hash(Request& r, const Stri Line 383  static void _hash(Request& r, const Stri
   
                         Array value_fields(pool);                          Array value_fields(pool);
                         if(param_index>0) {                          if(param_index>0) {
                                 Value& value_fields_param=params->as_no_junction(param_index, "value field(s) must not be code");                                  Value& value_fields_param=params.as_no_junction(param_index, "value field(s) must not be code");
                                 if(value_fields_param.is_string()) {                                  if(value_fields_param.is_string()) {
                                         value_fields+=self_table.column_name2index(value_fields_param.as_string(), true);                                          value_fields+=self_table.column_name2index(value_fields_param.as_string(), true);
                                 } else if(Table *value_fields_table=value_fields_param.get_table()) {                                  } else if(Table *value_fields_table=value_fields_param.get_table()) {
Line 402  static void _hash(Request& r, const Stri Line 402  static void _hash(Request& r, const Stri
                                         value_fields+=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;                          Value *key_code=key_param.get_junction()?&key_param:0;
                         int key_field=key_code?-1                          int key_field=key_code?-1
                                 :self_table.column_name2index(key_param.as_string(), true);                                  :self_table.column_name2index(key_param.as_string(), true);
Line 441  static int sort_cmp_double(const void *a Line 441  static int sort_cmp_double(const void *a
         else           else 
                 return 0;                  return 0;
 }  }
 static void _sort(Request& r, const String& method_name, MethodParams *params) {  static void _sort(Request& r, StringPtr method_name, MethodParams& params) {
         Pool& pool=r.pool();          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->size()>1/*..[desc|asc|]*/?          bool reverse=params.count()>1/*..[desc|asc|]*/?
                 reverse=params->as_no_junction(1, "order must not be code").as_string()=="desc":                  reverse=params.as_no_junction(1, "order must not be code").as_string()=="desc":
                 false; // default=asc                  false; // default=asc
   
         Table& old_table=static_cast<VTable *>(r.get_self())->table(&method_name);          Table& old_table=static_cast<VTable *>(r.get_self())->table(&method_name);
Line 482  static void _sort(Request& r, const Stri Line 482  static void _sort(Request& r, const Stri
         static_cast<VTable *>(r.get_self())->set_table(new_table);          static_cast<VTable *>(r.get_self())->set_table(new_table);
 }  }
   
 static bool _locate_expression(Request& r, const String& method_name, MethodParams *params) {  static bool _locate_expression(Request& r, StringPtr method_name, MethodParams& params) {
         if(params->size()>1)          if(params.count()>1)
                 throw Exception("parser.runtime",                   throw Exception("parser.runtime", 
                         &method_name,                          &method_name,
                         "locate by expression has only one parameter - expression");                          "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<VTable *>(r.get_self())->table(&method_name);          Table& table=static_cast<VTable *>(r.get_self())->table(&method_name);
         int saved_current=table.current();          int saved_current=table.current();
Line 502  static bool _locate_expression(Request& Line 502  static bool _locate_expression(Request&
         table.set_current(saved_current);          table.set_current(saved_current);
         return false;          return false;
 }  }
 static bool _locate_name_value(Request& r, const String& method_name, MethodParams *params) {  static bool _locate_name_value(Request& r, StringPtr method_name, MethodParams& params) {
         if(params->size()>2)          if(params.count()>2)
                 throw Exception("parser.runtime",                   throw Exception("parser.runtime", 
                         &method_name,                          &method_name,
                         "locate by name and value has only two parameters - name and value");                          "locate by name and value has only two parameters - name and value");
   
         Table& table=static_cast<VTable *>(r.get_self())->table(&method_name);          Table& table=static_cast<VTable *>(r.get_self())->table(&method_name);
         return table.locate(          return table.locate(
                 params->as_string(0, "column name must be string"),                  params.as_string(0, "column name must be string"),
                 params->as_string(1, "value 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();          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_expression(r, method_name, params) :
                 _locate_name_value(r, method_name, params);                  _locate_name_value(r, method_name, params);
         r.write_no_lang(*new(pool) VBool(pool, result));          r.write_no_lang(*new(pool) VBool(pool, 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();          Pool& pool=r.pool();
         Table& old_table=static_cast<VTable *>(r.get_self())->table(&method_name);          Table& old_table=static_cast<VTable *>(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*/);
Line 540  static void _flip(Request& r, const Stri Line 540  static void _flip(Request& r, const Stri
         r.write_no_lang(*new(pool) VTable(pool, &new_table));          r.write_no_lang(*new(pool) VTable(pool, &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();          Pool& pool=r.pool();
         // data          // data
         Temp_lang temp_lang(r, String::UL_PASS_APPENDED);          Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
         const String& string=          const String& string=
                 r.process_to_string(params->as_junction(0, "body must be code"));                  r.process_to_string(params.as_junction(0, "body must be code"));
   
         // parse cells          // parse cells
         Array& row=*new(pool) Array(pool);          Array& row=*new(pool) Array(pool);
Line 554  static void _append(Request& r, const St Line 554  static void _append(Request& r, const St
         static_cast<VTable *>(r.get_self())->table(&method_name)+=&row;          static_cast<VTable *>(r.get_self())->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();          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)          if(!maybe_src)
                 throw Exception("parser.runtime",                   throw Exception("parser.runtime", 
                         &method_name,                           &method_name, 
Line 667  public: Line 667  public:
         Table *table;          Table *table;
 };  };
 #endif  #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();          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 limit=0;
         ulong offset=0;          ulong offset=0;
         if(params->size()>1) {          if(params.count()>1) {
                 Value& voptions=params->as_no_junction(1, "options must be hash, not code");                  Value& voptions=params.as_no_junction(1, "options must be hash, not code");
                 if(!voptions.is_string())                  if(!voptions.is_string())
                         if(Hash *options=voptions.get_hash(&method_name)) {                          if(Hash *options=voptions.get_hash(&method_name)) {
                                 int valid_options=0;                                  int valid_options=0;
Line 732  static void _sql(Request& r, const Strin Line 732  static void _sql(Request& r, const Strin
         static_cast<VTable *>(r.get_self())->set_table(*result);          static_cast<VTable *>(r.get_self())->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();          Pool& pool=r.pool();
   
         Array& result_columns=*new(pool) Array(pool);          Array& result_columns=*new(pool) Array(pool);
Line 752  static void _columns(Request& r, const S Line 752  static void _columns(Request& r, const S
         r.write_no_lang(*new(pool) VTable(pool, &result_table));          r.write_no_lang(*new(pool) VTable(pool, &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();          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<VTable *>(r.get_self())->table(&method_name);          Table& source_table=static_cast<VTable *>(r.get_self())->table(&method_name);
         Table& result_table=*new(pool) Table(pool,           Table& result_table=*new(pool) Table(pool, 
Removed from v.1.172.2.2  
changed lines
  Added in v.1.172.2.3

E-mail: