[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.364 and 1.378

version 1.364, 2024/09/21 23:51:03 version 1.378, 2024/12/11 15:46:38
Line 1 Line 1
 /** @file  /** @file
         Parser: @b table parser class.          Parser: @b table parser class.
   
         Copyright (c) 2001-2023 Art. Lebedev Studio (http://www.artlebedev.com)          Copyright (c) 2001-2024 Art. Lebedev Studio (http://www.artlebedev.com)
         Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <paf@design.ru>          Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <paf@design.ru>
 */  */
   
Line 24 Line 24
 #include "pa_sql_connection.h"  #include "pa_sql_connection.h"
 #include "pa_vbool.h"  #include "pa_vbool.h"
 #include "pa_array.h"  #include "pa_array.h"
   #include "pa_varray.h"
   
 volatile const char * IDENT_TABLE_C="$Id$";  volatile const char * IDENT_TABLE_C="$Id$";
   
Line 259  static void _create(Request& r, MethodPa Line 260  static void _create(Request& r, MethodPa
   
         if(params.count()>1) {          if(params.count()>1) {
                 if(params[0].is_string()){ // can be nameless only                  if(params[0].is_string()){ // can be nameless only
                         const String& snameless=params.as_string(0, "called with more then 1 param, first param may be only string 'nameless' or junction");                          const String& snameless=params.as_string(0, "called with more than 1 param, first param may be only string 'nameless' or junction");
                         if(snameless!="nameless")                          if(snameless!="nameless")
                                 throw Exception(PARSER_RUNTIME, &snameless, "table::create called with more then 1 param, first param may be only 'nameless'");                                  throw Exception(PARSER_RUNTIME, &snameless, "table::create called with more than 1 param, first param may be only 'nameless'");
                         nameless=true;                          nameless=true;
                         data_param_index++;                          data_param_index++;
                 }                  }
Line 403  static void skip_empty_lines( char** dat Line 404  static void skip_empty_lines( char** dat
 typedef void (*Skip_lines_action)(char** data_ref);  typedef void (*Skip_lines_action)(char** data_ref);
   
 static void _load(Request& r, MethodParams& params) {  static void _load(Request& r, MethodParams& params) {
         const String&  first_param=params.as_string(0, FILE_NAME_MUST_BE_STRING);          const String&  first_param=params.as_file_name(0);
         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 416  static void _load(Request& r, MethodPara Line 417  static void _load(Request& r, MethodPara
                 control_chars.load(*options);                  control_chars.load(*options);
   
         // loading text          // loading text
         char *data=file_load_text(r, r.full_disk_path(params.as_string(filename_param_index, FILE_NAME_MUST_BE_STRING)), true, options);          char *data=file_load_text(r, r.full_disk_path(params.as_file_name(filename_param_index)), true, options);
   
         Skip_lines_action skip_lines_action = (control_chars.separator=='#' || control_chars.encloser=='#') ? skip_empty_lines : skip_empty_and_comment_lines;          Skip_lines_action skip_lines_action = (control_chars.separator=='#' || control_chars.encloser=='#') ? skip_empty_lines : skip_empty_and_comment_lines;
   
Line 623  static void table_to_csv(String& result, Line 624  static void table_to_csv(String& result,
   
   
 static void _save(Request& r, MethodParams& params) {  static void _save(Request& r, MethodParams& params) {
         const String& first_arg=params.as_string(0, FIRST_ARG_MUST_NOT_BE_CODE);          const String& first_arg=params.as_string(0, PARAMETER_MUST_BE_STRING);
         size_t param_index=1;          size_t param_index=1;
   
         bool do_append=false;          bool do_append=false;
Line 637  static void _save(Request& r, MethodPara Line 638  static void _save(Request& r, MethodPara
         else          else
                 --param_index;                  --param_index;
   
         const String& file_name=params.as_string(param_index++, FILE_NAME_MUST_NOT_BE_CODE);          const String& file_name=params.as_file_name(param_index++);
         String file_spec=r.full_disk_path(file_name);          String file_spec=r.full_disk_path(file_name);
   
         if(do_append && file_exist(file_spec))          if(do_append && file_exist(file_spec))
Line 682  static void _csv_string(Request& r, Meth Line 683  static void _csv_string(Request& r, Meth
         bool output_column_names=true;          bool output_column_names=true;
         size_t param_index=0;          size_t param_index=0;
         if(params.count()>0 && params[0].is_string()) {          if(params.count()>0 && params[0].is_string()) {
                 if(params.as_string(0, FIRST_ARG_MUST_NOT_BE_CODE)=="nameless") {                  if(params.as_string(0, PARAM_MUST_NOT_BE_CODE)=="nameless") {
                         output_column_names=false;                          output_column_names=false;
                         param_index++;                          param_index++;
                 } else {                  } else {
Line 750  static void _offset(Request& r, MethodPa Line 751  static void _offset(Request& r, MethodPa
                     else if(whence=="set")                      else if(whence=="set")
                                 absolute=true;                                  absolute=true;
                     else                      else
                                 throw Exception(PARSER_RUNTIME, &whence, "is invalid whence, valid are 'cur' or 'set'");                                  throw Exception(PARSER_RUNTIME, &whence, "is an invalid whence, valid are 'cur' or 'set'");
                 }                  }
                                   
                 int offset=params.as_int(params.count()-1, "offset must be expression", r);                  int offset=params.as_int(params.count()-1, "offset must be expression", r);
Line 767  static void _menu(Request& r, MethodPara Line 768  static void _menu(Request& r, MethodPara
         Value* delim_maybe_code=params.count()>1?&params[1]:0;          Value* delim_maybe_code=params.count()>1?&params[1]:0;
   
         Table& table=GET_SELF(r, VTable).table();          Table& table=GET_SELF(r, VTable).table();
         size_t saved_current=table.current();          Temp_current tc(table);
   
         if(delim_maybe_code) { // delimiter set          if(delim_maybe_code) { // delimiter set
                 bool need_delim=false;                  bool need_delim=false;
Line 800  static void _menu(Request& r, MethodPara Line 801  static void _menu(Request& r, MethodPara
                                 break;                                  break;
                 }                  }
         }          }
         table.set_current(saved_current);  
 }  }
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
Line 849  static void table_row_to_hash(Table::ele Line 849  static void table_row_to_hash(Table::ele
                                 for(Array_iterator<int> i(*info->value_fields); i; ) {                                  for(Array_iterator<int> i(*info->value_fields); i; ) {
                                         size_t value_field=i.next();                                          size_t value_field=i.next();
                                         if(value_field<row->count())                                          if(value_field<row->count())
                                                 hash.put(columns ? *columns->get(value_field) : String(format(value_field, 0)), new VString(*row->get(value_field)));                                                  hash.put(columns ? *columns->get(value_field) : String(pa_uitoa(value_field)), new VString(*row->get(value_field)));
                                 }                                  }
                         } else { // all fields                          } else { // all fields
                                 for(size_t index=0; index<row->count(); index++) {                                  for(size_t index=0; index<row->count(); index++) {
                                         hash.put(columns && index < columns->count() ? *columns->get(index) : String(format(index, 0)), new VString(*row->get(index)));                                          hash.put(columns && index < columns->count() ? *columns->get(index) : String(pa_uitoa(index)), new VString(*row->get(index)));
                                 }                                  }
                         }                          }
                         exist=info->hash->put_dont_replace(*key, vhash);                          exist=info->hash->put_dont_replace(*key, vhash);
Line 983  static void _hash(Request& r, MethodPara Line 983  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't specify more then one value field with option $.type[string]");                          throw Exception(PARSER_RUNTIME, 0, "you can't specify more than one value field with option $.type[string]");
         }          }
   
         Value* key_param=&params[0];          Value* key_param=&params[0];
Line 1001  static void _hash(Request& r, MethodPara Line 1001  static void _hash(Request& r, MethodPara
         };          };
         info.key_field=(info.key_code ? -1 : self_table.column_name2index(key_param->as_string(), true));          info.key_field=(info.key_code ? -1 : self_table.column_name2index(key_param->as_string(), true));
   
         int saved_current=self_table.current();          Temp_current tc(self_table);
         self_table.for_each(table_row_to_hash, &info);          for(Table::RobustIterator i(self_table); i; i.next()) {
         self_table.set_current(saved_current);                  table_row_to_hash(i.value(), &info);
           }
   
         result.extract_default();          result.extract_default();
   
         r.write(result);          r.write(result);
 }  }
   
   static void _array(Request& r, MethodParams& params) {
           Table& table=GET_SELF(r, VTable).table();
           VArray& result=*new VArray;
           ArrayValue& array=result.array();
   
           Table2hash_value_type value_type=C_HASH;
           Array<int> value_fields;
           Value* value_code=0;
   
           if(params.count()>0) {
                   if(params[0].get_junction()){
                           value_type=C_CODE;
                           value_code=&params[0];
                   } else if(params[0].is_string()) {
                           const String &field_name=*params[0].get_string();
                           if(!field_name.is_empty()){
                                   value_type=C_STRING;
                                   value_fields+=table.column_name2index(field_name, true);
                           }
                   } else {
                           throw Exception(PARSER_RUNTIME, 0, "value field must be string or code or empty");
                   }
           }
   
           Temp_current tc(table);
           for(Table::RobustIterator i(table); i; i.next()) {
                   switch(value_type) {
                           case C_STRING: {
                                   size_t index=value_fields.get(0);
                                   Table::element_type row=i.value();
                                   array+=(index < row->count() ? new VString(*row->get(index)) : VString::empty());
                                   break;
                           }
                           case C_HASH: {
                                   VHash* vhash=new VHash;
                                   HashStringValue& hash=vhash->hash();
                                   Table::element_type row=i.value();
                                   Table::columns_type columns=table.columns();
                                   for(size_t index=0; index<row->count(); index++) {
                                           hash.put(columns && index < columns->count() ? *columns->get(index) : String(pa_uitoa(index)), new VString(*row->get(index)));
                                   }
                                   array+=vhash;
                                   break;
                           }
                           case C_CODE: {
                                   table.set_current(i.index());
                                   array+=&r.process(*value_code);
                                   break;
                           }
                   }
           }
   
           r.write(result);
   }
   
   static void _cells(Request& r, MethodParams& params) {
           Table& self_table=GET_SELF(r, VTable).table();
           size_t row_size=self_table[self_table.current()]->count(); // number of columns in current row
   
           if(params.count()){
                   int limit=params.as_int(params.count()-1, "offset must be expression", r);
                   if(limit<0)
                           limit=0;
                   if((size_t)limit<row_size)
                           row_size=limit;
           }
   
           VArray& result=*new VArray(row_size);
           ArrayValue& result_array=result.array();
   
           for(size_t index=0; index<row_size; index++){
                   const String* column_item=self_table.item(index);
                   result_array+=column_item ? new VString(*column_item) : VString::empty();
           }
   
           result_array.confirm_all_used();
           r.write(result);
   }
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct Table_seq_item : public PA_Allocated {  struct Table_seq_item : public PA_Allocated {
         ArrayString* row;          ArrayString* row;
Line 1148  static void _foreach(Request& r, MethodP Line 1228  static void _foreach(Request& r, MethodP
         Value* delim_maybe_code=params.count()>3?&params[3]:0;          Value* delim_maybe_code=params.count()>3?&params[3]:0;
   
         Table& table=GET_SELF(r, VTable).table();          Table& table=GET_SELF(r, VTable).table();
         size_t saved_current=table.current();          Temp_current tc(table);
   
         rownum_var_name=rownum_var_name->is_empty()? 0 : rownum_var_name;          rownum_var_name=rownum_var_name->is_empty()? 0 : rownum_var_name;
         value_var_name=value_var_name->is_empty()? 0 : value_var_name;          value_var_name=value_var_name->is_empty()? 0 : value_var_name;
Line 1196  static void _foreach(Request& r, MethodP Line 1276  static void _foreach(Request& r, MethodP
                                 break;                                  break;
                 }                  }
         }          }
         table.set_current(saved_current);  
 }  }
   
 static void update_cell(HashStringValue::key_type aname, HashStringValue::value_type avalue, VTable *dest) {  static void update_cell(HashStringValue::key_type aname, HashStringValue::value_type avalue, VTable *dest) {
Line 1222  static void _append(Request& r, MethodPa Line 1301  static void _append(Request& r, MethodPa
   
         HashStringValue* hash=params[0].get_hash();          HashStringValue* hash=params[0].get_hash();
         if(hash){          if(hash){
                   Temp_current tc(table);
                 table+=new ArrayString();                  table+=new ArrayString();
                 size_t saved_current=table.current();  
                 table.set_current(table.count()-1);                  table.set_current(table.count()-1);
                 hash->for_each<VTable*>(update_cell, &vtable);                  hash->for_each<VTable*>(update_cell, &vtable);
                 table.set_current(saved_current);  
         } else {          } else {
                 table+=row_from_string(r, params[0]);                  table+=row_from_string(r, params[0]);
         }          }
Line 1477  static void _select(Request& r, MethodPa Line 1555  static void _select(Request& r, MethodPa
         if(offset<0)          if(offset<0)
                 offset+=size;                  offset+=size;
         if(size && limit>0 && offset>=0 && (size_t)offset<size){          if(size && limit>0 && offset>=0 && (size_t)offset<size){
                 size_t saved_current=source_table.current();                  Temp_current tcurrent(source_table);
                 size_t appended=0;                  size_t appended=0;
   
                 if(reverse){                  if(reverse){
Line 1489  static void _select(Request& r, MethodPa Line 1567  static void _select(Request& r, MethodPa
                                 if(r.check_skip_break())                                  if(r.check_skip_break())
                                         break;                                          break;
   
                                 if(condition && ++appended > (size_t)offset) // ...condition is true, adding to the result                                  if(condition && ++appended > (size_t)offset && source_table.valid(row)) // ...condition is true, adding to the result
                                         result_table+=source_table[row];                                          result_table+=source_table[row];
                                 if(row==0) break;                                  if(row==0) break;
                         }                          }
Line 1502  static void _select(Request& r, MethodPa Line 1580  static void _select(Request& r, MethodPa
                                 if(r.check_skip_break())                                  if(r.check_skip_break())
                                         break;                                          break;
   
                                 if(condition && ++appended > (size_t)offset) // ...condition is true, adding to the result                                  if(condition && ++appended > (size_t)offset && source_table.valid(row)) // ...condition is true, adding to the result
                                         result_table+=source_table[row];                                          result_table+=source_table[row];
                         }                          }
                 }                  }
                 source_table.set_current(saved_current);  
         }          }
   
         r.write(*new VTable(&result_table));          r.write(*new VTable(&result_table));
Line 1527  static void _rename(Request& r, MethodPa Line 1604  static void _rename(Request& r, MethodPa
         Table& table=GET_SELF(r, VTable).table();          Table& table=GET_SELF(r, VTable).table();
         if(Table::columns_type columns=table.columns()) {          if(Table::columns_type columns=table.columns()) {
                 if(names){                  if(names){
                         for(int i=0; i<columns->count(); i++) {                          for(size_t i=0; i<columns->count(); i++) {
                                 const String *column = columns->get(i);                                  const String *column = columns->get(i);
                                 if(Value* vto=names->get(*column)){                                  if(Value* vto=names->get(*column)){
                                         if(const String *sto=vto->get_string())                                          if(const String *sto=vto->get_string())
Line 1537  static void _rename(Request& r, MethodPa Line 1614  static void _rename(Request& r, MethodPa
                                 }                                  }
                         }                          }
                 } else if(name_from){                  } else if(name_from){
                         for(int i=0; i<columns->count(); i++) {                          for(size_t i=0; i<columns->count(); i++) {
                                 const String *column = columns->get(i);                                  const String *column = columns->get(i);
                                 if(*column == *name_from)                                  if(*column == *name_from)
                                         columns->put(i, name_to);                                          columns->put(i, name_to);
Line 1595  MTable::MTable(): Methoded("table") { Line 1672  MTable::MTable(): Methoded("table") {
         // ^table.hash[key field name][value field name(s) string/table]          // ^table.hash[key field name][value field name(s) string/table]
         add_native_method("hash", Method::CT_DYNAMIC, _hash, 1, 3);          add_native_method("hash", Method::CT_DYNAMIC, _hash, 1, 3);
   
           // ^table.array[]
           // ^table.array[string]
           // ^table.array{code}
           add_native_method("array", Method::CT_DYNAMIC, _array, 0, 1);
   
           // ^table.cells[]
           // ^table.cells(limit)
           add_native_method("cells", Method::CT_DYNAMIC, _cells, 0, 1);
   
         // ^table.sort{string-key-maker} ^table.sort{string-key-maker}[desc|asc]          // ^table.sort{string-key-maker} ^table.sort{string-key-maker}[desc|asc]
         // ^table.sort(numeric-key-maker) ^table.sort(numeric-key-maker)[desc|asc]          // ^table.sort(numeric-key-maker) ^table.sort(numeric-key-maker)[desc|asc]
         add_native_method("sort", Method::CT_DYNAMIC, _sort, 1, 2);          add_native_method("sort", Method::CT_DYNAMIC, _sort, 1, 2);
Removed from v.1.364  
changed lines
  Added in v.1.378

E-mail: