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

Diff for /parser3/src/classes/array.C between versions 1.9 and 1.16

version 1.9, 2024/09/22 17:01:23 version 1.16, 2024/10/02 17:58:15
Line 46  static void _create_or_add(Request& r, M Line 46  static void _create_or_add(Request& r, M
   
                 if(VArray* src=dynamic_cast<VArray*>(&vsrc)) {                  if(VArray* src=dynamic_cast<VArray*>(&vsrc)) {
                         if(src==&self)                          if(src==&self)
                                 throw Exception(PARSER_RUNTIME, 0, "source and destination are the same array");                                  return;
                         self_array.append(src->array());                          if(self_array.count()){
                                   for(ArrayValue::Iterator i(src->array()); i; i.next()){
                                           if(i.value())
                                                   self_array.put(i.index(), i.value());
                                   }
                           } else {
                                   self_array.append(src->array());
                           }
                 } else {                  } else {
                         HashStringValue* src_hash=vsrc.get_hash();                          HashStringValue* src_hash=vsrc.as_hash("param must be array or");
                         if(!src_hash)                          if(!src_hash)
                                 return;                                  return;
                         for(HashStringValue::Iterator i(*src_hash); i; i.next()){                          for(HashStringValue::Iterator i(*src_hash); i; i.next()){
Line 119  static void _join(Request& r, MethodPara Line 126  static void _join(Request& r, MethodPara
                         }                          }
                 }                  }
         } else {          } else {
                 HashStringValue* src_hash=vsrc.get_hash();                  HashStringValue* src_hash=vsrc.as_hash("param must be array or");
                 if(!src_hash)                  if(!src_hash)
                         return;                          return;
                 if(o.defined){                  if(o.defined){
Line 141  static void _join(Request& r, MethodPara Line 148  static void _join(Request& r, MethodPara
         self.invalidate();          self.invalidate();
 }  }
   
 static void _sql(Request& r, MethodParams& params) {}  #ifndef DOXYGEN
   
   #define STRING(str) ((str) ? *new String(str, String::L_TAINTED /* no length as 0x00 can be inside */) : String::Empty)
   
   class SparseArray_sql_event_handlers: public SQL_Driver_query_event_handlers {
           bool distinct;
           ArrayValue& result;
           Value* row_value;
           int column_index;
           ArrayString* columns;
           bool one_bool_column;
           Table2hash_value_type value_type;
           int columns_count;
   public:
           Table* empty;
   public:
           SparseArray_sql_event_handlers(bool adistinct, ArrayValue& aresult, Table2hash_value_type avalue_type):
                   distinct(adistinct),
                   result(aresult),
                   row_value(0),
                   column_index(0),
                   columns(new ArrayString),
                   one_bool_column(false),
                   value_type(avalue_type),
                   empty(0) {
           }
   
           bool add_column(SQL_Error& error, const char* str, size_t ) {
                   try {
                           if(columns_count){
                                   // another query in multi_statements mode
                                   columns=new ArrayString;
                                   columns_count=0;
                           }
                           *columns+=&STRING(str);
                           return false;
                   } catch(...) {
                           error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_column");
                           return true;
                   }
           }
   
           bool before_rows(SQL_Error& error) {
                   columns_count=columns->count();
                   if(columns_count<1) {
                           error=SQL_Error("no columns");
                           return true;
                   }
                   if(columns_count==1) {
                           one_bool_column=true;
                   } else {
                           switch(value_type){
                                   case C_STRING: {
                                           if(columns_count>2){
                                                   error=SQL_Error("only 2 columns allowed for $.type[string] and $.sparse(true)");
                                                   return true;
                                           }
                                           break;
                                   }
                                   case C_TABLE: {
                                           // create empty table which we'll copy later
                                           empty=new Table(columns);
                                           break;
                                   }
                           }
                   }
                   return false;
           }
   
           bool add_row(SQL_Error& /*error*/) {
                   column_index=0;
                   return false;
           }
   
           bool add_row_cell(SQL_Error& error, const char *str, size_t ) {
                   try {
                           if(column_index==columns_count){
                                   // should never happen, buggy driver case
                                   error=SQL_Error("columns index exceed the columns count");
                                   return true;
                           }
   
                           bool duplicate=false;
                           if(one_bool_column) {
                                   size_t index=str ? pa_atoui(str) : 0;
                                   duplicate=result.put_dont_replace(index, &VBool::get(true));  // put. existed?
                           } else if(column_index==0) {
                                   size_t index=str ? pa_atoui(str) : 0;
                                   switch(value_type){
                                           case C_HASH: {
                                                   VHash* row_vhash=new VHash;
                                                   row_value=row_vhash;
                                                   duplicate=result.put_dont_replace(index, row_vhash); // put. existed?
                                                   break;
                                           }
                                           case C_STRING: {
                                                   VString* row_vstring=new VString();
                                                   row_value=row_vstring;
                                                   duplicate=result.put_dont_replace(index, row_vstring);  // put. existed?
                                                   break;
                                           }
                                           case C_TABLE: {
                                                   VTable* vtable=(VTable*)result.get(index);
   
                                                   if(vtable) { // table with this key exist?
                                                           if(!distinct) {
                                                                   duplicate=true;
                                                                   break;
                                                           }
                                                   } else {
                                                           // no? creating table of same structure as source
                                                           Table::Action_options table_options(0, 0);
                                                           vtable=new VTable(new Table(*empty, table_options/*no rows, just structure*/));
                                                           result.put(index, vtable); // put
                                                   }
                                                   ArrayString* row=new ArrayString(columns_count);
                                                   *row+=&STRING(str);
                                                   *vtable->get_table()+=row;
                                                   row_value=(Value*)row;
                                                   break;
                                           }
                                   }
                           } else {
                                   const String& cell=STRING(str);
                                   switch(value_type) {
                                           case C_HASH: {
                                                   row_value->get_hash()->put(*columns->get(column_index), new VString(cell));
                                                   break;
                                           }
                                           case C_STRING: {
                                                   VString* row_string=(VString*)row_value;
                                                   row_string->set_string(cell);
                                                   break;
                                           }
                                           case C_TABLE: {
                                                   ArrayString* row=(ArrayString*)row_value;
                                                   *row+=&cell;
                                                   break;
                                           }
                                   }
                           }
   
                           if(duplicate & !distinct) {
                                   error=SQL_Error("duplicate key");
                                   return true;
                           }
   
                           column_index++;
                           return false;
                   } catch(const Exception& e) {
                           error=SQL_Error(e.type(), e.comment());
                           return true;
                   } catch(...) {
                           error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_row_cell");
                           return true;
                   }
           }
   };
   
   class Array_sql_event_handlers: public SQL_Driver_query_event_handlers {
           ArrayValue& result;
           Value* row_value;
           int column_index;
           ArrayString* columns;
           Table2hash_value_type value_type;
           int columns_count;
   public:
           Table* empty;
   public:
           Array_sql_event_handlers(ArrayValue& aresult, Table2hash_value_type avalue_type):
                   result(aresult),
                   row_value(0),
                   column_index(0),
                   columns(new ArrayString),
                   value_type(avalue_type),
                   empty(0) {
           }
   
           bool add_column(SQL_Error& error, const char* str, size_t ) {
                   try {
                           if(columns_count){
                                   // another query in multi_statements mode
                                   columns=new ArrayString;
                                   columns_count=0;
                           }
                           *columns+=&STRING(str);
                           return false;
                   } catch(...) {
                           error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_column");
                           return true;
                   }
           }
   
           bool before_rows(SQL_Error& error) {
                   columns_count=columns->count();
                   if(columns_count<1) {
                           error=SQL_Error("no columns");
                           return true;
                   }
                   switch(value_type){
                           case C_STRING: {
                                   if(columns_count>1){
                                           error=SQL_Error("only one column allowed for $.type[string]");
                                           return true;
                                   }
                                   break;
                           }
                           case C_TABLE: {
                                   // create empty table which we'll copy later
                                   empty=new Table(columns);
                                   break;
                           }
                   }
                   return false;
           }
   
           bool add_row(SQL_Error& /*error*/) {
                   column_index=0;
                   return false;
           }
   
           bool add_row_cell(SQL_Error& error, const char *str, size_t ) {
                   try {
                           if(column_index==columns_count){
                                   // should never happen, buggy driver case
                                   error=SQL_Error("columns index exceed the columns count");
                                   return true;
                           }
   
                           if(column_index==0) {
                                   switch(value_type){
                                           case C_HASH: {
                                                   VHash* row_vhash=new VHash;
                                                   row_value=row_vhash;
                                                   result+=row_vhash;
                                                   break;
                                           }
                                           case C_STRING: {
                                                   VString* row_vstring=new VString();
                                                   row_value=row_vstring;
                                                   result+=row_vstring;
                                                   break;
                                           }
                                           case C_TABLE: {
                                                   // creating table of same structure as source
                                                   Table::Action_options table_options(0, 0);
                                                   VTable* vtable=new VTable(new Table(*empty, table_options/*no rows, just structure*/));
                                                   ArrayString* row=new ArrayString(columns_count);
                                                   *vtable->get_table()+=row;
                                                   row_value=(Value*)row;
                                                   result+=vtable;
                                                   break;
                                           }
                                   }
                           }
   
                           const String& cell=STRING(str);
                           switch(value_type) {
                                   case C_HASH: {
                                           row_value->get_hash()->put(*columns->get(column_index), new VString(cell));
                                           break;
                                   }
                                   case C_STRING: {
                                           VString* row_string=(VString*)row_value;
                                           row_string->set_string(cell);
                                           break;
                                   }
                                   case C_TABLE: {
                                           ArrayString* row=(ArrayString*)row_value;
                                           *row+=&cell;
                                           break;
                                   }
                           }
   
                           column_index++;
                           return false;
                   } catch(const Exception& e) {
                           error=SQL_Error(e.type(), e.comment());
                           return true;
                   } catch(...) {
                           error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_row_cell");
                           return true;
                   }
           }
   };
   
   #endif
   
   extern Table2hash_value_type get_value_type(Value& vvalue_type);
   extern int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders);
   extern void unmarshal_bind_updates(HashStringValue& hash, int placeholder_count, SQL_Driver::Placeholder* placeholders);
   
   static void _sql(Request& r, MethodParams& params) {
           Value& statement=params.as_junction(0, "statement must be code");
   
           HashStringValue* bind=0;
           ulong limit=SQL_NO_LIMIT;
           ulong offset=0;
           bool distinct=false;
           bool sparse=false;
           Table2hash_value_type value_type=C_HASH;
           if(params.count()>1)
                   if(HashStringValue* options=params.as_hash(1, "sql options")) {
                           int valid_options=0;
                           bool distinct_specified=false;
                           for(HashStringValue::Iterator i(*options); i; i.next() ){
                                   String::Body key=i.key();
                                   Value* value=i.value();
                                   if(key == sql_bind_name) {
                                           bind=value->get_hash();
                                           valid_options++;
                                   } else if(key == sql_limit_name) {
                                           limit=(ulong)r.process(*value).as_double();
                                           valid_options++;
                                   } else if(key == sql_offset_name) {
                                           offset=(ulong)r.process(*value).as_double();
                                           valid_options++;
                                   } else if (key == sql_distinct_name) {
                                           distinct=r.process(*value).as_bool();
                                           distinct_specified=true;
                                           valid_options++;
                                   } else if (key == sql_value_type_name) {
                                           value_type=get_value_type(r.process(*value));
                                           valid_options++;
                                   } else if (key == "sparse") {
                                           sparse=r.process(*value).as_bool();
                                           valid_options++;
                                   }
                           }
                           if(valid_options!=options->count())
                                   throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
                           if(distinct_specified && !sparse)
                                   throw Exception(PARSER_RUNTIME, 0, "'distinct' option can only be used when $.sparse(true) is specified");
                   }
   
           SQL_Driver::Placeholder* placeholders=0;
           uint placeholders_count=0;
           if(bind)
                   placeholders_count=marshal_binds(*bind, placeholders);
   
           const String& statement_string=r.process_to_string(statement);
           const char* statement_cstr=statement_string.untaint_cstr(String::L_SQL, r.connection());
   
           VArray& self=GET_SELF(r, VArray);
   
           self.array().clear(); self.invalidate(); // just in case if called as method
   
           if(sparse){
                   SparseArray_sql_event_handlers handlers(distinct, self.array(), value_type);
                   r.connection()->query(statement_cstr, placeholders_count, placeholders, offset, limit, handlers, statement_string);
           } else {
                   Array_sql_event_handlers handlers(self.array(), value_type);
                   r.connection()->query(statement_cstr, placeholders_count, placeholders, offset, limit, handlers, statement_string);
           }
   
           if(bind)
                   unmarshal_bind_updates(*bind, placeholders_count, placeholders);
   }
   
   
   
 static void mid(Request& r, ArrayValue::Action_options o) {  static void mid(Request& r, size_t offset=0, size_t limit=ARRAY_OPTION_LIMIT_ALL) {
         ArrayValue& array=GET_SELF(r, VArray).array();          ArrayValue& array=GET_SELF(r, VArray).array();
         if(o.limit>0){          if(limit>0){
                 VArray *result=new VArray;                  VArray *result=new VArray;
                 ArrayValue& result_array=result->array();                  ArrayValue& result_array=result->array();
                 for(ArrayValue::Iterator i(array); i; i.next()){                  for(ArrayValue::Iterator i(array); i; i.next()){
                         if(i.value()){                          if(i.value()){
                                 if(o.offset > 0){                                  if(offset > 0){
                                         o.offset--;                                          offset--;
                                         continue;                                          continue;
                                 }                                  }
                                 if(o.limit-- == 0)                                  if(limit-- == 0)
                                         break;                                          break;
                                 result_array+=i.value();                                  result_array+=i.value();
                         }                          }
Line 168  static void mid(Request& r, ArrayValue:: Line 533  static void mid(Request& r, ArrayValue::
   
 static void _left(Request& r, MethodParams& params) {  static void _left(Request& r, MethodParams& params) {
         int sn=params.as_int(0, "n must be int", r);          int sn=params.as_int(0, "n must be int", r);
         mid(r, ArrayValue::Action_options(0, sn < 0 ? 0 : sn));          mid(r, 0, sn < 0 ? 0 : sn);
 }  }
   
 static void _right(Request& r, MethodParams& params) {  static void _right(Request& r, MethodParams& params) {
Line 177  static void _right(Request& r, MethodPar Line 542  static void _right(Request& r, MethodPar
         if(sn>0){          if(sn>0){
                 size_t used=GET_SELF(r, VArray).array().used();                  size_t used=GET_SELF(r, VArray).array().used();
                 if(sn<used){                  if(sn<used){
                         mid(r, ArrayValue::Action_options(used-sn, sn));                          mid(r, used-sn, sn);
                 } else {                  } else {
                         mid(r, ArrayValue::Action_options());                          mid(r);
                 }                  }
         } else {          } else {
                 mid(r, ArrayValue::Action_options(0, 0));                  mid(r, 0, 0);
         }          }
 }  }
   
Line 200  static void _mid(Request& r, MethodParam Line 565  static void _mid(Request& r, MethodParam
                 int n=params.as_int(1, "n must be int", r);                  int n=params.as_int(1, "n must be int", r);
                 if(n<0)                  if(n<0)
                         throw Exception(PARSER_RUNTIME, 0, "n(%d) must be >=0", n);                          throw Exception(PARSER_RUNTIME, 0, "n(%d) must be >=0", n);
                 mid(r, ArrayValue::Action_options(begin, n));                  mid(r, begin, n);
         } else {          } else {
                 mid(r, ArrayValue::Action_options(begin));                  mid(r, begin);
         }          }
 }  }
   
Line 501  enum AtResultType { Line 866  enum AtResultType {
         AtResultTypeHash = 2          AtResultTypeHash = 2
 };  };
   
 inline Value& SingleElementHash(String::Body akey, Value* avalue) {  static Value& SingleElementHash(String::Body akey, Value* avalue) {
         Value& result=*new VHash;          Value& result=*new VHash;
         result.put_element(*new String(akey, String::L_TAINTED), avalue);          result.put_element(*new String(akey, String::L_TAINTED), avalue);
         return result;          return result;
Line 734  MArray::MArray(): Methoded(VARRAY_TYPE) Line 1099  MArray::MArray(): Methoded(VARRAY_TYPE)
 #ifdef FEATURE_GET_ELEMENT4CALL  #ifdef FEATURE_GET_ELEMENT4CALL
         // aliases without "_"          // aliases without "_"
         add_native_method("keys", Method::CT_DYNAMIC, _keys, 0, 1);          add_native_method("keys", Method::CT_DYNAMIC, _keys, 0, 1);
         add_native_method("count", Method::CT_DYNAMIC, _count, 0, 0);          add_native_method("count", Method::CT_DYNAMIC, _count, 0, 1);
         add_native_method("at", Method::CT_DYNAMIC, _at, 1, 2);          add_native_method("at", Method::CT_DYNAMIC, _at, 1, 2);
 #endif  #endif
   
Removed from v.1.9  
changed lines
  Added in v.1.16

E-mail: