Annotation of parser3/src/classes/hash.C, revision 1.108
1.1 paf 1: /** @file
2: Parser: @b hash parser class.
3:
1.89 misha 4: Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)
1.35 paf 5: Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
1.41 paf 6: */
1.1 paf 7:
1.108 ! moko 8: static const char * const IDENT_HASH_C="$Date: 2010-10-05 20:56:12 $";
1.1 paf 9:
10: #include "classes.h"
1.57 paf 11: #include "pa_vmethod_frame.h"
12:
1.1 paf 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"
1.9 parser 17: #include "pa_vtable.h"
1.22 parser 18: #include "pa_vbool.h"
1.26 paf 19: #include "pa_vmethod_frame.h"
1.2 parser 20:
1.1 paf 21: // class
22:
1.57 paf 23: class MHash: public Methoded {
1.2 parser 24: public: // VStateless_class
1.103 misha 25: Value* create_new_value(Pool&) { return new VHash(); }
1.2 parser 26:
1.1 paf 27: public:
1.57 paf 28: MHash();
1.1 paf 29: };
30:
1.57 paf 31: // global variable
32:
33: DECLARE_CLASS_VAR(hash, new MHash, 0);
34:
1.1 paf 35: // methods
36:
1.11 parser 37: #ifndef DOXYGEN
1.52 paf 38: class Hash_sql_event_handlers: public SQL_Driver_query_event_handlers {
1.57 paf 39: const String& statement_string; const char* statement_cstr;
40: bool distinct;
41: HashStringValue& rows_hash;
1.86 misha 42: Value* row_value;
1.57 paf 43: int column_index;
1.86 misha 44: ArrayString& columns;
45: bool one_bool_column;
1.67 paf 46: static VBool only_one_column_value;
1.86 misha 47: Table2hash_value_type value_type;
48: int columns_count;
49: public:
50: Table* empty;
1.11 parser 51: public:
1.57 paf 52: Hash_sql_event_handlers(
1.86 misha 53: const String& astatement_string,
54: const char* astatement_cstr,
1.49 paf 55: bool adistinct,
1.86 misha 56: HashStringValue& arows_hash,
57: Table2hash_value_type avalue_type)
58: :
59: statement_string(astatement_string),
60: statement_cstr(astatement_cstr),
1.49 paf 61: distinct(adistinct),
1.11 parser 62: rows_hash(arows_hash),
1.86 misha 63: value_type(avalue_type),
64: row_value(0),
1.67 paf 65: column_index(0),
1.86 misha 66: one_bool_column(false),
67: columns(*new ArrayString),
68: empty(0) {
1.11 parser 69: }
1.86 misha 70:
1.96 misha 71: bool add_column(SQL_Error& error, const char* str, size_t length) {
1.53 paf 72: try {
1.107 moko 73: columns+=new String(str, String::L_TAINTED /* no length as 0x00 can be inside */);
1.53 paf 74: return false;
75: } catch(...) {
76: error=SQL_Error("exception occured in Hash_sql_event_handlers::add_column");
77: return true;
78: }
1.11 parser 79: }
1.86 misha 80:
1.53 paf 81: bool before_rows(SQL_Error& error) {
1.67 paf 82: if(columns.count()<1) {
1.79 misha 83: error=SQL_Error(PARSER_RUNTIME, "no columns");
1.53 paf 84: return true;
85: }
1.86 misha 86: switch(value_type){
87: case C_STRING: {
88: if(columns.count()>2){
89: error=SQL_Error(PARSER_RUNTIME, "only 2 columns allowed for $.type[string].");
90: return true;
91: }
92: }
93: case C_TABLE: {
94: // create empty table which we'll copy later
95: empty=new Table(&columns);
96: columns_count=columns.count();
97: }
98: case C_HASH: {
99: one_bool_column=columns.count()==1;
100: }
101: }
1.53 paf 102: return false;
1.11 parser 103: }
1.86 misha 104:
1.53 paf 105: bool add_row(SQL_Error& /*error*/) {
1.11 parser 106: column_index=0;
1.53 paf 107: return false;
1.11 parser 108: }
1.86 misha 109:
1.96 misha 110: bool add_row_cell(SQL_Error& error, const char *ptr, size_t length) {
1.53 paf 111: try {
1.107 moko 112: String& cell=*new String(ptr, String::L_TAINTED /* no length as 0x00 can be inside */);
1.86 misha 113:
1.69 paf 114: bool duplicate=false;
1.86 misha 115: if(one_bool_column) {
1.69 paf 116: duplicate=rows_hash.put_dont_replace(cell, &only_one_column_value); // put. existed?
117: } else if(column_index==0) {
1.86 misha 118: switch(value_type){
119: case C_HASH: {
120: VHash* row_vhash=new VHash;
121: row_value=row_vhash;
122: duplicate=rows_hash.put_dont_replace(cell, row_vhash); // put. existed?
123: break;
124: }
125: case C_STRING: {
126: VString* row_vstring=new VString();
127: row_value=row_vstring;
128: duplicate=rows_hash.put_dont_replace(cell, row_vstring); // put. existed?
129: break;
130: }
131: case C_TABLE: {
132: VTable* vtable=(VTable*)rows_hash.get(cell);
133: Table* table;
134:
135: if(vtable) { // table with this key exist?
136: if(!distinct) {
137: duplicate=true;
138: break;
139: }
140: table=vtable->get_table();
141: } else {
142: // no? creating table of same structure as source
143: Table::Action_options table_options(0, 0);
144: table=new Table(*empty, table_options/*no rows, just structure*/);
145: vtable=new VTable(table);
146: rows_hash.put(cell, vtable); // put
147: }
148: ArrayString* row=new ArrayString(columns_count);
149: row_value=(Value*)row;
150: *row+=&cell;
151: *table+=row;
152: break;
153: }
154: }
155: } else {
156: switch(value_type) {
157: case C_HASH: {
158: row_value->get_hash()->put(*columns[column_index], new VString(cell));
159: break;
160: }
161: case C_STRING: {
162: VString* row_string=(VString*)row_value;
163: row_string->set_string(cell);
164: break;
165: }
166: case C_TABLE: {
167: ArrayString* row=(ArrayString*)row_value;
168: *row+=&cell;
169: break;
170: }
171: }
172: }
1.69 paf 173:
174: if(duplicate & !distinct) {
1.79 misha 175: error=SQL_Error(PARSER_RUNTIME, "duplicate key");
1.69 paf 176: return true;
177: }
178:
1.53 paf 179: column_index++;
180: return false;
181: } catch(...) {
182: error=SQL_Error("exception occured in Hash_sql_event_handlers::add_row_cell");
183: return true;
184: }
1.11 parser 185: }
186:
187: };
1.67 paf 188: VBool Hash_sql_event_handlers::only_one_column_value(true);
189:
1.11 parser 190: #endif
191:
1.57 paf 192: static void _create_or_add(Request& r, MethodParams& params) {
193: if(params.count()) {
1.66 paf 194: Value& vsrc=params.as_no_junction(0, "param must be hash");
195: if(HashStringValue* src=vsrc.get_hash()) {
1.72 paf 196: VHash& self=GET_SELF(r, VHash);
197: HashStringValue* self_hash=&(self.hash());
198: if(src==self_hash) // same: doing nothing
1.66 paf 199: return;
1.77 paf 200: src->for_each<HashStringValue*>(copy_all_overwrite_to, self_hash);
1.72 paf 201:
1.103 misha 202: if(VHash* vhash_src=static_cast<VHash*>(vsrc.as(VHASH_TYPE)))
1.78 paf 203: {
204: if(Value* vdefault=vhash_src->get_default())
205: {
206: if(vdefault->is_defined())
207: {
208: self.set_default(vdefault);
209: }
210: }
211: }
1.66 paf 212: }
1.20 parser 213: }
214: }
1.22 parser 215:
1.57 paf 216: static void _sub(Request& r, MethodParams& params) {
1.66 paf 217: Value& vsrc=params.as_no_junction(0, "param must be hash");
218: if(HashStringValue* src=vsrc.get_hash()) {
219: HashStringValue* self=&(GET_SELF(r, VHash).hash());
220: if(src==self) { // same: clearing
221: self->clear();
222: return;
223: }
1.77 paf 224: src->for_each<HashStringValue*>(remove_key_from, self);
1.66 paf 225: }
1.57 paf 226: }
227:
228: static void copy_all_dontoverwrite_to(
1.100 misha 229: HashStringValue::key_type key,
230: HashStringValue::value_type value,
231: HashStringValue* dest) {
1.57 paf 232: dest->put_dont_replace(key, value);
1.22 parser 233: }
1.57 paf 234: static void _union(Request& r, MethodParams& params) {
1.22 parser 235: // dest = copy of self
1.57 paf 236: Value& result=*new VHash(GET_SELF(r, VHash).hash());
1.22 parser 237: // dest += b
1.66 paf 238: Value& vsrc=params.as_no_junction(0, "param must be hash");
239: if(HashStringValue* src=vsrc.get_hash())
1.77 paf 240: src->for_each<HashStringValue*>(copy_all_dontoverwrite_to, result.get_hash());
1.22 parser 241:
242: // return result
243: r.write_no_lang(result);
244: }
245:
246: #ifndef DOXYGEN
247: struct Copy_intersection_to_info {
1.57 paf 248: HashStringValue* b;
249: HashStringValue* dest;
1.22 parser 250: };
251: #endif
1.57 paf 252: static void copy_intersection_to(
1.100 misha 253: HashStringValue::key_type key,
254: HashStringValue::value_type value,
255: Copy_intersection_to_info *info) {
1.57 paf 256: if(info->b->get(key))
257: info->dest->put_dont_replace(key, value);
1.22 parser 258: }
1.57 paf 259: static void _intersection(Request& r, MethodParams& params) {
260: Value& result=*new VHash;
1.22 parser 261: // dest += b
1.57 paf 262: Value& vb=params.as_no_junction(0, "param must be hash");
263: if(HashStringValue* b=vb.get_hash()) {
264: Copy_intersection_to_info info={b, result.get_hash()};
1.77 paf 265: GET_SELF(r, VHash).hash().for_each<Copy_intersection_to_info*>(copy_intersection_to, &info);
1.22 parser 266: }
267:
268: // return result
1.57 paf 269: r.write_no_lang(result);
1.22 parser 270: }
271:
1.57 paf 272: static bool intersects(
1.100 misha 273: HashStringValue::key_type key,
274: HashStringValue::value_type /*value*/,
275: HashStringValue* b) {
1.57 paf 276: return b->get(key)!=0;
1.22 parser 277: }
278:
1.57 paf 279: static void _intersects(Request& r, MethodParams& params) {
280: bool result=false;
281:
282: Value& vb=params.as_no_junction(0, "param must be hash");
283: if(HashStringValue* b=vb.get_hash())
1.77 paf 284: result=GET_SELF(r, VHash).hash().first_that<HashStringValue*>(intersects, b)!=0;
1.22 parser 285:
286: // return result
1.89 misha 287: r.write_no_lang(VBool::get(result));
1.22 parser 288: }
289:
290:
1.71 paf 291: extern String sql_bind_name;
1.57 paf 292: extern String sql_limit_name;
293: extern String sql_offset_name;
294: extern String sql_default_name;
295: extern String sql_distinct_name;
1.81 misha 296: extern String sql_value_type_name;
297: extern Table2hash_value_type get_value_type(Value& vvalue_type);
1.71 paf 298: extern int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders);
299: extern void unmarshal_bind_updates(HashStringValue& hash, int placeholder_count, SQL_Driver::Placeholder* placeholders);
300:
1.57 paf 301: static void _sql(Request& r, MethodParams& params) {
302: Value& statement=params.as_junction(0, "statement must be code");
1.2 parser 303:
1.71 paf 304: HashStringValue* bind=0;
1.87 misha 305: ulong limit=SQL_NO_LIMIT;
1.33 paf 306: ulong offset=0;
1.49 paf 307: bool distinct=false;
1.81 misha 308: Table2hash_value_type value_type=C_HASH;
1.57 paf 309: if(params.count()>1) {
310: Value& voptions=params.as_no_junction(1, "options must be hash, not code");
1.76 paf 311: if(voptions.is_defined() && !voptions.is_string())
1.57 paf 312: if(HashStringValue* options=voptions.get_hash()) {
1.49 paf 313: int valid_options=0;
1.71 paf 314: if(Value* vbind=options->get(sql_bind_name)) {
315: valid_options++;
316: bind=vbind->get_hash();
317: }
1.57 paf 318: if(Value* vlimit=options->get(sql_limit_name)) {
1.88 misha 319: valid_options++;
320: limit=(ulong)r.process_to_value(*vlimit).as_double();
1.49 paf 321: }
1.57 paf 322: if(Value* voffset=options->get(sql_offset_name)) {
1.49 paf 323: valid_options++;
1.37 paf 324: offset=(ulong)r.process_to_value(*voffset).as_double();
1.49 paf 325: }
1.57 paf 326: if(Value* vdistinct=options->get(sql_distinct_name)) {
1.49 paf 327: valid_options++;
328: distinct=r.process_to_value(*vdistinct).as_bool();
329: }
1.81 misha 330: if(Value* vvalue_type=options->get(sql_value_type_name)) {
331: valid_options++;
332: value_type=get_value_type(r.process_to_value(*vvalue_type));
333: }
1.57 paf 334: if(valid_options!=options->count())
1.104 misha 335: throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
1.33 paf 336: } else
1.104 misha 337: throw Exception(PARSER_RUNTIME, 0, OPTIONS_MUST_BE_HASH);
1.2 parser 338: }
339:
1.71 paf 340: SQL_Driver::Placeholder* placeholders=0;
341: uint placeholders_count=0;
342: if(bind)
343: placeholders_count=marshal_binds(*bind, placeholders);
344:
1.57 paf 345: Temp_lang temp_lang(r, String::L_SQL);
1.37 paf 346: const String& statement_string=r.process_to_string(statement);
1.99 misha 347: const char* statement_cstr=statement_string.untaint_cstr(r.flang, r.connection());
1.97 misha 348:
1.57 paf 349: HashStringValue& hash=GET_SELF(r, VHash).hash();
1.11 parser 350: hash.clear();
1.57 paf 351: Hash_sql_event_handlers handlers(
1.49 paf 352: statement_string, statement_cstr,
353: distinct,
1.86 misha 354: hash,
355: value_type);
1.87 misha 356:
1.57 paf 357: r.connection()->query(
1.70 paf 358: statement_cstr,
1.73 paf 359: placeholders_count, placeholders,
1.70 paf 360: offset, limit,
1.45 paf 361: handlers,
362: statement_string);
1.71 paf 363:
364: if(bind)
365: unmarshal_bind_updates(*bind, placeholders_count, placeholders);
1.2 parser 366: }
367:
1.57 paf 368: static void keys_collector(
1.100 misha 369: HashStringValue::key_type key,
370: HashStringValue::value_type,
371: Table *table) {
372: Table::element_type row(new ArrayString(1));
1.57 paf 373: *row+=new String(key, String::L_TAINTED);
374: *table+=row;
1.9 parser 375: }
1.68 paf 376: static void _keys(Request& r, MethodParams& params) {
377: const String* keys_column_name;
378: if(params.count()>0)
1.81 misha 379: keys_column_name=¶ms.as_string(0, COLUMN_NAME_MUST_BE_STRING);
1.68 paf 380: else
381: keys_column_name=new String("key");
382:
1.101 misha 383: Table::columns_type columns(new ArrayString(1));
1.68 paf 384: *columns+=keys_column_name;
1.57 paf 385: Table* table=new Table(columns);
1.9 parser 386:
1.77 paf 387: GET_SELF(r, VHash).hash().for_each<Table*>(keys_collector, table);
1.9 parser 388:
1.57 paf 389: r.write_no_lang(*new VTable(table));
1.9 parser 390: }
391:
1.57 paf 392: static void _count(Request& r, MethodParams&) {
393: r.write_no_lang(*new VInt(GET_SELF(r, VHash).hash().count()));
1.16 parser 394: }
395:
1.57 paf 396: static void _delete(Request& r, MethodParams& params) {
1.25 paf 397:
1.57 paf 398: GET_SELF(r, VHash).hash().remove(params.as_string(0, "key must be string"));
1.25 paf 399: }
400:
1.82 misha 401: static void _contains(Request& r, MethodParams& params) {
1.89 misha 402: bool result=GET_SELF(r, VHash).hash().contains(params.as_string(0, "key must be string"));
403: r.write_no_lang(VBool::get(result));
1.80 misha 404: }
405:
1.26 paf 406: #ifndef DOXYGEN
1.59 paf 407: struct Foreach_info {
1.26 paf 408: Request *r;
409: const String* key_var_name;
410: const String* value_var_name;
1.57 paf 411: Value* body_code;
412: Value* delim_maybe_code;
1.26 paf 413:
1.84 misha 414: Value* var_context;
1.26 paf 415: bool need_delim;
416: };
417: #endif
1.90 misha 418: static bool one_foreach_cycle(
419: HashStringValue::key_type akey,
420: HashStringValue::value_type avalue,
421: Foreach_info *info) {
1.84 misha 422: Value& var_context=*info->var_context;
1.85 misha 423: if(info->key_var_name){
1.96 misha 424: VString* vkey=new VString(*new String(akey, String::L_TAINTED));
1.103 misha 425: var_context.put_element(*info->key_var_name, vkey, false);
1.85 misha 426: }
427: if(info->value_var_name)
1.103 misha 428: var_context.put_element(*info->value_var_name, avalue, false);
1.57 paf 429:
1.91 misha 430: if(info->delim_maybe_code){ // delimiter set
1.90 misha 431: StringOrValue sv_processed=info->r->process(*info->body_code);
432: Request::Skip lskip=info->r->get_skip(); info->r->set_skip(Request::SKIP_NOTHING);
433:
434: const String* s_processed=sv_processed.get_string();
1.91 misha 435: if(s_processed && !s_processed->is_empty()) { // we have body
1.90 misha 436: if(info->need_delim) // need delim & iteration produced string?
437: info->r->write_pass_lang(info->r->process(*info->delim_maybe_code));
438: else
439: info->need_delim=true;
440: }
441: info->r->write_pass_lang(sv_processed);
442: return lskip==Request::SKIP_BREAK;
443: } else {
444: info->r->process_write(*info->body_code);
445: Request::Skip lskip=info->r->get_skip(); info->r->set_skip(Request::SKIP_NOTHING);
446: return lskip==Request::SKIP_BREAK;
1.26 paf 447: }
448: }
1.57 paf 449: static void _foreach(Request& r, MethodParams& params) {
1.102 misha 450: InCycle temp(r);
1.77 paf 451:
1.85 misha 452: const String& key_var_name=params.as_string(0, "key-var name must be string");
453: const String& value_var_name=params.as_string(1, "value-var name must be string");
454:
1.63 paf 455: Foreach_info info={
456: &r,
1.85 misha 457: key_var_name.is_empty()? 0 : &key_var_name,
458: value_var_name.is_empty()? 0 : &value_var_name,
1.63 paf 459: ¶ms.as_junction(2, "body must be code"),
1.84 misha 460: /*delimiter*/params.count()>3?params.get(3):0,
461: /*var_context*/r.get_method_frame()->caller(),
1.85 misha 462: false
1.63 paf 463: };
1.57 paf 464:
465: VHash& self=GET_SELF(r, VHash);
466: HashStringValue& hash=self.hash();
1.28 paf 467: VHash_lock lock(self);
1.77 paf 468: hash.first_that<Foreach_info*>(one_foreach_cycle, &info);
1.26 paf 469: }
470:
1.105 misha 471: static void _at(Request& r, MethodParams& params) {
472: HashStringValue& hash=GET_SELF(r, VHash).hash();
473: size_t count=hash.count();
474:
475: int pos=0;
476:
477: Value& vwhence=*params.get(0);
478: if(vwhence.is_string()){
479: const String& swhence=*vwhence.get_string();
480: if(swhence == "last")
481: pos=count-1;
482: else if(swhence != "first")
483: throw Exception(PARSER_RUNTIME,
484: &swhence,
485: "whence must be 'first', 'last' or expression");
486: } else {
487: pos=r.process_to_value(vwhence).as_int();
488: if(pos < 0)
489: pos+=count;
490: }
491:
1.106 misha 492: if(count && pos >= 0 && (size_t)pos < count){
1.105 misha 493: if(pos == 0)
494: r.write_assign_lang(*hash.first_value());
1.106 misha 495: else if((size_t)pos == count-1)
1.105 misha 496: r.write_assign_lang(*hash.last_value());
497: else
498: for(HashStringValue::Iterator i(hash); i; i.next(), pos-- )
499: if(!pos){
500: r.write_assign_lang(*i.value());
501: break;
502: }
503: }
504:
505: }
506:
1.1 paf 507: // constructor
508:
1.57 paf 509: MHash::MHash(): Methoded("hash")
1.39 paf 510: {
1.21 parser 511: // ^hash::create[[copy_from]]
1.57 paf 512: add_native_method("create", Method::CT_DYNAMIC, _create_or_add, 0, 1);
1.22 parser 513: // ^hash.add[add_from]
1.57 paf 514: add_native_method("add", Method::CT_DYNAMIC, _create_or_add, 1, 1);
1.22 parser 515: // ^hash.sub[sub_from]
516: add_native_method("sub", Method::CT_DYNAMIC, _sub, 1, 1);
517: // ^a.union[b] = hash
518: add_native_method("union", Method::CT_DYNAMIC, _union, 1, 1);
519: // ^a.intersection[b] = hash
520: add_native_method("intersection", Method::CT_DYNAMIC, _intersection, 1, 1);
521: // ^a.intersects[b] = bool
522: add_native_method("intersects", Method::CT_DYNAMIC, _intersects, 1, 1);
1.25 paf 523:
524: // ^a.delete[key]
525: add_native_method("delete", Method::CT_DYNAMIC, _delete, 1, 1);
1.2 parser 526:
1.82 misha 527: // ^a.contains[key]
528: add_native_method("contains", Method::CT_DYNAMIC, _contains, 1, 1);
529: // backward
530: add_native_method("contain", Method::CT_DYNAMIC, _contains, 1, 1);
1.80 misha 531:
532: // ^hash::sql[query][options hash]
1.33 paf 533: add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 2);
1.2 parser 534:
1.68 paf 535: // ^hash._keys[[column name]]
536: add_native_method("_keys", Method::CT_DYNAMIC, _keys, 0, 1);
1.16 parser 537:
538: // ^hash._count[]
539: add_native_method("_count", Method::CT_DYNAMIC, _count, 0, 0);
1.26 paf 540:
541: // ^hash.foreach[key;value]{code}[delim]
542: add_native_method("foreach", Method::CT_DYNAMIC, _foreach, 2+1, 2+1+1);
1.105 misha 543:
544: // ^hash._at[first|last]
545: // ^hash._at([-]offset)
546: add_native_method("_at", Method::CT_DYNAMIC, _at, 1, 1);
1.1 paf 547: }
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hash.C CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / classes