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

Diff for /parser3/src/classes/hash.C between versions 1.10 and 1.13

version 1.10, 2001/07/07 16:38:01 version 1.13, 2001/08/06 09:33:19
Line 46  static void _default(Request& r, const S Line 46  static void _default(Request& r, const S
         }          }
 }  }
   
   #ifndef DOXYGEN
   class Hash_sql_event_handlers : public SQL_Driver_query_event_handlers {
   public:
           Hash_sql_event_handlers(Pool& apool, const String& amethod_name,
                   const String& astatement_string, const char *astatement_cstr,
                   Hash& arows_hash) :
                   pool(apool), 
                   method_name(amethod_name),
                   statement_string(astatement_string),
                   statement_cstr(astatement_cstr),
                   rows_hash(arows_hash),
                   columns(pool),
                   row_index(0) {
           }
           void add_column(void *ptr, size_t size) {
                   String *column=new(pool) String(pool);
                   column->APPEND_TAINTED(
                           (const char *)ptr, size, 
                           statement_cstr, 0);
                   columns+=column;
           }
           void before_rows() { 
                   if(columns.size()<=1)
                           PTHROW(0, 0,
                                   &method_name,
                                   "column count must be more than 1 to create a hash");
           }
           void add_row() {
                   column_index=0;
           }
           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, row_index++);
                   if(column_index==0) {
                           VHash *row_vhash=new(pool) VHash(pool);
                           row_hash=row_vhash->get_hash();
                           rows_hash.put(*cell, row_vhash);
                   } else
                           row_hash->put(*columns.get_string(column_index), new(pool) VString(*cell));
                   column_index++;
           }
   
   private:
           Pool& pool;
           const String& method_name;
           const String& statement_string; const char *statement_cstr;
           Hash& rows_hash;
           Hash *row_hash;
           int column_index;
           Array columns;
           int row_index;
   };
   #endif
   
 static void _sql(Request& r, const String& method_name, MethodParams *params) {  static void _sql(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
Line 72  static void _sql(Request& r, const Strin Line 129  static void _sql(Request& r, const Strin
         const String& statement_string=r.process(statement).as_string();          const String& statement_string=r.process(statement).as_string();
         const char *statement_cstr=          const char *statement_cstr=
                 statement_string.cstr(String::UL_UNSPECIFIED, r.connection);                  statement_string.cstr(String::UL_UNSPECIFIED, r.connection);
         unsigned int sql_column_count; SQL_Driver::Cell *sql_columns;          Hash& hash=static_cast<VHash *>(r.self)->hash();
         unsigned long sql_row_count; SQL_Driver::Cell **sql_rows;          hash.clear();   
           Hash_sql_event_handlers handlers(pool, method_name,
                   statement_string, statement_cstr, hash);
         bool need_rethrow=false; Exception rethrow_me;          bool need_rethrow=false; Exception rethrow_me;
         PTRY {          PTRY {
                 r.connection->query(                  r.connection->query(
                         statement_cstr, offset, limit,                          statement_cstr, offset, limit,
                         &sql_column_count, &sql_columns,                          handlers);
                         &sql_row_count, &sql_rows);  
         }          }
         PCATCH(e) { // query problem          PCATCH(e) { // query problem
                 rethrow_me=e;  need_rethrow=true;                  rethrow_me=e;  need_rethrow=true;
Line 89  static void _sql(Request& r, const Strin Line 147  static void _sql(Request& r, const Strin
                 PTHROW(rethrow_me.type(), rethrow_me.code(),                  PTHROW(rethrow_me.type(), rethrow_me.code(),
                         &statement_string, // setting more specific source [were url]                          &statement_string, // setting more specific source [were url]
                         rethrow_me.comment());                          rethrow_me.comment());
   
         Hash& rows_hash=static_cast<VHash *>(r.self)->hash();  
         rows_hash.clear();        
   
         if(sql_column_count<=1)  
                 return;  
   
         Array& columns=*new(pool) Array(pool);  
         for(unsigned int i=0+1; i<sql_column_count; i++) {  
                 String& column=*new(pool) String(pool);  
                 column.APPEND_TAINTED(  
                         (const char *)sql_columns[i].ptr, sql_columns[i].size,  
                         statement_cstr, 0);  
                 columns+=&column;  
         }  
           
         for(unsigned long row=0; row<sql_row_count; row++) {  
                 SQL_Driver::Cell *sql_cells=sql_rows[row];                        
                   
                 VHash& row_vhash=*new(pool) VHash(pool);  
                 Hash& row_hash=*row_vhash.get_hash();  
                 String *key=0; // calm, compiler  
                 String *cell;  
                 for(unsigned int i=0; i<sql_column_count; i++) {  
                         cell=new(pool) String(pool);  
                         cell->APPEND_TAINTED(  
                                 (const char *)sql_cells[i].ptr, sql_cells[i].size,  
                                 statement_cstr, row);  
                         if(i==0)  
                                 key=cell;  
                         else  
                                 row_hash.put(*columns.get_string(i-1), new(pool) VString(*cell));  
                 }  
                 rows_hash.put(*key, &row_vhash);  
         }  
 }  }
   
 static void keys_collector(const Hash::Key& key, Hash::Val *value, void *info) {  static void keys_collector(const Hash::Key& key, Hash::Val *value, void *info) {
Line 161  MHash::MHash(Pool& apool) : Methoded(apo Line 184  MHash::MHash(Pool& apool) : Methoded(apo
         add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 3);          add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 3);
   
         // ^hash.keys[]          // ^hash.keys[]
         add_native_method("keys", Method::CT_DYNAMIC, _keys, 0, 0);               add_native_method("_keys", Method::CT_DYNAMIC, _keys, 0, 0);    
 }  }
   
 // global variable  // global variable
Removed from v.1.10  
changed lines
  Added in v.1.13

E-mail: