Return to hash.C CVS log

Up to [parser3project] / parser3 / src / classes

Annotation of parser3/src/classes/hash.C, revision 1.8

1.1       paf         1: /** @file
                      2:        Parser: @b hash parser class.
                      3: 
                      4:        Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
                      5: 
                      6:        Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
                      7: 
1.8     ! parser      8:        $Id: hash.C,v 1.7 2001/06/28 07:41:59 parser Exp $
1.1       paf         9: */
1.8     ! parser     10: static const char *RCSId="$Id: double.C,v 1.31 2001/06/28 07:41:59 parser Exp $"; 
1.1       paf        11: 
                     12: #include "classes.h"
                     13: #include "pa_request.h"
                     14: #include "pa_vhash.h"
1.6       parser     15: #include "pa_vvoid.h"
1.2       parser     16: #include "pa_sql_connection.h"
                     17: 
                     18: // defines
                     19: 
                     20: #define HASH_CLASS_NAME "hash"
1.1       paf        21: 
                     22: // class
                     23: 
                     24: class MHash : public Methoded {
1.2       parser     25: public: // VStateless_class
                     26:        Value *create_new_value(Pool& pool) { return new(pool) VHash(pool); }
                     27: 
1.1       paf        28: public:
                     29:        MHash(Pool& pool);
                     30: public: // Methoded
1.2       parser     31:        bool used_directly() { return true; }
1.1       paf        32: };
                     33: 
                     34: // methods
                     35: 
                     36: static void _default(Request& r, const String&, MethodParams *params) { 
                     37:        Pool& pool=r.pool();
                     38: 
                     39:        VHash& vhash=*static_cast<VHash *>(r.self);
                     40:        if(params->size())
                     41:                vhash.set_default(params->get(0)); // info: may be code..
                     42:        else {
                     43:                Value *default_value=vhash.get_default();
1.6       parser     44:                r.write_assign_lang(default_value?*default_value:*new(pool) VVoid(pool));
1.1       paf        45:        }
                     46: }
                     47: 
1.2       parser     48: static void _sql(Request& r, const String& method_name, MethodParams *params) {
                     49:        Pool& pool=r.pool();
                     50: 
                     51:        if(!r.connection)
                     52:                PTHROW(0, 0,
                     53:                        &method_name,
                     54:                        "without connect");
                     55: 
                     56:        Value& statement=params->get_junction(0, "statement must be code");
                     57: 
                     58:        ulong limit=0;
                     59:        if(params->size()>1) {
                     60:                Value& limit_code=params->get_junction(1, "limit must be expression");
                     61:                limit=(uint)r.process(limit_code).as_double();
                     62:        }
                     63: 
                     64:        ulong offset=0;
                     65:        if(params->size()>2) {
                     66:                Value& offset_code=params->get_junction(2, "offset must be expression");
                     67:                offset=(ulong)r.process(offset_code).as_double();
                     68:        }
                     69: 
                     70:        Temp_lang temp_lang(r, String::UL_SQL);
                     71:        const String& statement_string=r.process(statement).as_string();
                     72:        const char *statement_cstr=
                     73:                statement_string.cstr(String::UL_UNSPECIFIED, r.connection);
                     74:        unsigned int sql_column_count; SQL_Driver::Cell *sql_columns;
                     75:        unsigned long sql_row_count; SQL_Driver::Cell **sql_rows;
                     76:        bool need_rethrow=false; Exception rethrow_me;
                     77:        PTRY {
                     78:                r.connection->query(
                     79:                        statement_cstr, offset, limit,
                     80:                        &sql_column_count, &sql_columns,
                     81:                        &sql_row_count, &sql_rows);
                     82:        }
1.3       parser     83:        PCATCH(e) { // query problem
1.2       parser     84:                rethrow_me=e;  need_rethrow=true;
                     85:        }
                     86:        PEND_CATCH
                     87:        if(need_rethrow)
                     88:                PTHROW(rethrow_me.type(), rethrow_me.code(),
                     89:                        &statement_string, // setting more specific source [were url]
                     90:                        rethrow_me.comment());
                     91: 
                     92:        Hash& rows_hash=static_cast<VHash *>(r.self)->hash();
                     93:        rows_hash.clear();      
                     94: 
                     95:        if(sql_column_count<=1)
                     96:                return;
                     97: 
                     98:        Array& columns=*new(pool) Array(pool);
                     99:        for(unsigned int i=0+1; i<sql_column_count; i++) {
                    100:                String& column=*new(pool) String(pool);
                    101:                column.APPEND_TAINTED(
                    102:                        (const char *)sql_columns[i].ptr, sql_columns[i].size,
                    103:                        statement_cstr, 0);
                    104:                columns+=&column;
                    105:        }
                    106:        
                    107:        for(unsigned long row=0; row<sql_row_count; row++) {
                    108:                SQL_Driver::Cell *sql_cells=sql_rows[row];                      
                    109:                
                    110:                VHash& row_vhash=*new(pool) VHash(pool);
                    111:                Hash& row_hash=*row_vhash.get_hash();
                    112:                String *key=0; // calm, compiler
                    113:                String *cell;
                    114:                for(unsigned int i=0; i<sql_column_count; i++) {
                    115:                        cell=new(pool) String(pool);
                    116:                        cell->APPEND_TAINTED(
                    117:                                (const char *)sql_cells[i].ptr, sql_cells[i].size,
                    118:                                statement_cstr, row);
                    119:                        if(i==0)
                    120:                                key=cell;
                    121:                        else
                    122:                                row_hash.put(*columns.get_string(i-1), new(pool) VString(*cell));
                    123:                }
                    124:                rows_hash.put(*key, &row_vhash);
                    125:        }
                    126: }
                    127: 
1.1       paf       128: // constructor
                    129: 
                    130: MHash::MHash(Pool& apool) : Methoded(apool) {
1.2       parser    131:        set_name(*NEW String(pool(), HASH_CLASS_NAME));
                    132: 
1.1       paf       133:        // ^hash.default[]
                    134:        // ^hash.default[hash]
                    135:        add_native_method("default", Method::CT_DYNAMIC, _default, 0, 1);
1.2       parser    136: 
                    137:        // ^hash:sql[query][(count[;offset])]
                    138:        add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 3);
                    139: 
1.1       paf       140: }
                    141: 
                    142: // global variable
                    143: 
                    144: Methoded *hash_base_class;
                    145: 
                    146: // creator
                    147: 
                    148: Methoded *MHash_create(Pool& pool) {
                    149:        return hash_base_class=new(pool) MHash(pool);
                    150: }