[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.187 and 1.219

version 1.187, 2003/11/04 10:49:34 version 1.219, 2005/11/28 12:50:18
Line 1 Line 1
 /** @file  /** @file
         Parser: @b table parser class.          Parser: @b table parser class.
   
         Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com)
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */  */
   static const char * const IDENT_TABLE_C="$Date$";
 static const char* IDENT_TABLE_C="$Date$";  
   
 #include "classes.h"  #include "classes.h"
 #include "pa_vmethod_frame.h"  #include "pa_vmethod_frame.h"
Line 21  static const char* IDENT_TABLE_C="$Date$ Line 20  static const char* IDENT_TABLE_C="$Date$
   
 class MTable: public Methoded {  class MTable: public Methoded {
 public: // VStateless_class  public: // VStateless_class
         Value* create_new_value() { return new VTable(); }          Value* create_new_value(Pool&, HashStringValue&) { return new VTable(); }
   
 public:  public:
         MTable();          MTable();
Line 36  DECLARE_CLASS_VAR(table, new MTable, 0); Line 35  DECLARE_CLASS_VAR(table, new MTable, 0);
   
 // defines for globals  // defines for globals
   
 #define SQL_LIMIT_NAME "limit"  #define SQL_BIND_NAME "bind"
 #define SQL_OFFSET_NAME "offset"  
 #define SQL_DEFAULT_NAME "default"  #define SQL_DEFAULT_NAME "default"
 #define SQL_DISTINCT_NAME "distinct"  #define SQL_DISTINCT_NAME "distinct"
 #define TABLE_REVERSE_NAME "reverse"  #define TABLE_REVERSE_NAME "reverse"
   
 // globals  // globals
   
 String sql_limit_name(SQL_LIMIT_NAME);  String sql_bind_name(SQL_BIND_NAME);
 String sql_offset_name(SQL_OFFSET_NAME);  String sql_limit_name(PA_SQL_LIMIT_NAME);
   String sql_offset_name(PA_SQL_OFFSET_NAME);
 String sql_default_name(SQL_DEFAULT_NAME);  String sql_default_name(SQL_DEFAULT_NAME);
 String sql_distinct_name(SQL_DISTINCT_NAME);  String sql_distinct_name(SQL_DISTINCT_NAME);
 String table_reverse_name(TABLE_REVERSE_NAME);  String table_reverse_name(TABLE_REVERSE_NAME);
   
 // local defines  
   
 #define COLUMN_SEPARATOR_NAME "separator"  
 #define COLUMN_ENCLOSER_NAME "encloser"  
   
   
 // methods  // methods
   
 static Table::Action_options get_action_options(Request& r, MethodParams& params,   static Table::Action_options get_action_options(Request& r, MethodParams& params, 
Line 71  static Table::Action_options get_action_ Line 64  static Table::Action_options get_action_
         ]          ]
         but there is ^table.locate[name;value]          but there is ^table.locate[name;value]
   
           ...if(voptions.is_defined() && !voptions.is_string()))
         if(maybe_options.is_string()) { // allow empty options          if(maybe_options.is_string()) { // allow empty options
                 result.defined=true;                  result.defined=true;
                 return result;                  return result;
Line 144  static void _create(Request& r, MethodPa Line 138  static void _create(Request& r, MethodPa
         size_t raw_pos_after=0;          size_t raw_pos_after=0;
         Table::columns_type columns;          Table::columns_type columns;
         if(params.count()==2) {          if(params.count()==2) {
                   const String& snameless=params.as_string(0, "called with two params, first param may only be string 'nameless'");
                   if(snameless!="nameless")
                           throw Exception("parser.runtime",
                                   &snameless,
                                   "table::create called with two params, first param may only be 'nameless'");
                 columns=Table::columns_type(0); // nameless                  columns=Table::columns_type(0); // nameless
         } else {          } else {
                 columns=Table::columns_type(new ArrayString);                  columns=Table::columns_type(new ArrayString);
Line 178  static void _create(Request& r, MethodPa Line 177  static void _create(Request& r, MethodPa
         GET_SELF(r, VTable).set_table(table);          GET_SELF(r, VTable).set_table(table);
 }  }
   
 static char* remove_encloser(char* cstr, char encloser) {  
         if(cstr[0]!=encloser)  
                 return cstr;  
   
         size_t length=strlen(cstr);  
         if(length<2 || cstr[length-1]!=encloser)  
                 return cstr;  
   
         // 'string'  
   
         cstr[length-1]=0;  
         cstr++;  
   
         // double-encloser stands for encloser  
         char *read;  
         char *write;  
         write=read=cstr;  
         while(char c=*read++) {  
                 if(c==encloser && *read==encloser)  
                         read++;  
   
                 *write++=c;  
         }  
         *write=0; // terminate  
   
         return cstr;  
 }  
   
 struct lsplit_result {  struct lsplit_result {
         char* piece;          char* piece;
         char delim;          char delim;
Line 249  static lsplit_result lsplit(char** strin Line 220  static lsplit_result lsplit(char** strin
                         char *write;                          char *write;
                         write=read=string;                          write=read=string;
                         char c;                          char c;
                         while(c=*read++) {                          while((c=*read++)) {
                                 if(c==encloser) {                                  if(c==encloser) {
                                         char n=*read;                                          char n=*read;
                                         if(n==encloser) // double-encloser stands for encloser                                          if(n==encloser) // double-encloser stands for encloser
Line 279  static void skip_empty_and_comment_lines Line 250  static void skip_empty_and_comment_lines
                 while( char c=*data ) {                  while( char c=*data ) {
                         if( c== '\n' || c == '#' ) {                          if( c== '\n' || c == '#' ) {
                                 /*nowhere=*/getrow(&data); // remove empty&comment lines                                  /*nowhere=*/getrow(&data); // remove empty&comment lines
                                 *data_ref=data;                                  if(!(*data_ref=data))
                                           break;
                                 continue;                                  continue;
                         }                          }
                         break;                          break;
Line 288  static void skip_empty_and_comment_lines Line 260  static void skip_empty_and_comment_lines
 }  }
   
 struct TableSeparators {  struct TableSeparators {
         char column;          char column;  const String* scolumn;
         char encloser;          char encloser; const String* sencloser;
   
         TableSeparators() {          TableSeparators():
                 column='\t';                  column('\t'), scolumn(new String("\t", false)),
                 encloser=0;                  encloser(0), sencloser(0)
         }          {}
         void load( HashStringValue& options ) {          int load( HashStringValue& options ) {
                 if(Value* vseparator=options.get(COLUMN_SEPARATOR_NAME)) {                  int result=0;
                         options.remove(COLUMN_SEPARATOR_NAME);                  if(Value* vseparator=options.get(PA_COLUMN_SEPARATOR_NAME)) {
                         const String& sseparator=vseparator->as_string();                          scolumn=&vseparator->as_string();
                         if(sseparator.length()!=1)                          if(scolumn->length()!=1)
                                 throw Exception("parser.runtime",                                  throw Exception("parser.runtime",
                                         &sseparator,                                          scolumn,
                                         "separator must be one character long");                                          "separator must be one character long");
                         column=sseparator.first_char();                          column=scolumn->first_char();
                           result++;
                 }                  }
                 if(Value* vencloser=options.get(COLUMN_ENCLOSER_NAME)) {                  if(Value* vencloser=options.get(PA_COLUMN_ENCLOSER_NAME)) {
                         options.remove(COLUMN_ENCLOSER_NAME);                          sencloser=&vencloser->as_string();
                         const String& sencloser=vencloser->as_string();                          if(sencloser->length()!=1)
                         if(sencloser.length()!=1)  
                                 throw Exception("parser.runtime",                                  throw Exception("parser.runtime",
                                         &sencloser,                                          sencloser,
                                         "encloser must be one character long");                                          "encloser must be one character long");
                         encloser=sencloser.first_char();                          encloser=sencloser->first_char();
                           result++;
                 }                  }
                   return result;
         }          }
 };  };
   
Line 357  static void _load(Request& r, MethodPara Line 331  static void _load(Request& r, MethodPara
         }          }
                   
         Table& table=*new Table(columns);          Table& table=*new Table(columns);
           int columns_count=columns? columns->count(): 0;
   
         // parse cells          // parse cells
         Table::element_type row(new ArrayString);          Table::element_type row(new ArrayString(columns_count));
         skip_empty_and_comment_lines(&data);          skip_empty_and_comment_lines(&data);
         while( lsplit_result sr=lsplit(&data, separators.column, '\n', separators.encloser) ) {          while( lsplit_result sr=lsplit(&data, separators.column, '\n', separators.encloser) ) {
                 if(!sr.delim && !row->count()) // append last empty column [if without \n]                  if(!*sr.piece && !sr.delim && !row->count()) // append last empty column [if without \n]
                         break;                          break;
                 *row+=new String(sr.piece, 0, true);                  *row+=new String(sr.piece, 0, true);
                 if(sr.delim=='\n') {                  if(sr.delim=='\n') {
                         table+=row;                          table+=row;
                         row=new ArrayString;                          row=new ArrayString(columns_count);
                         skip_empty_and_comment_lines(&data);                          skip_empty_and_comment_lines(&data);
                 }                  }
         }          }
Line 379  static void _load(Request& r, MethodPara Line 354  static void _load(Request& r, MethodPara
         GET_SELF(r, VTable).set_table(table);          GET_SELF(r, VTable).set_table(table);
 }  }
   
 /// @todo "x\nx" "xxx""xx"  static void maybe_enclose( String& to, const String& from, char encloser, const String* sencloser ) {
           if(encloser) {
                   to<<*sencloser;
                   // while we have 'encloser'...
                   size_t pos_after=0;
                   for( size_t pos_before; (pos_before=from.pos( encloser, pos_after ))!=STRING_NOT_FOUND; pos_after=pos_before+1) {
               to<<from.mid(pos_before+1/*+found encloser*/, pos_after-pos_before);
                           to<<*sencloser;  to<<*sencloser; // doubling encloser
                   }
                   // last piece
                   size_t from_length=from.length();
                   if(pos_after<from_length)
                           to<<from.mid(pos_after, from_length);
   
                   to<<*sencloser;
           } else
                   to<<from;
   }
   
   
 static void _save(Request& r, MethodParams& params) {  static void _save(Request& r, MethodParams& params) {
         Value& vfile_name=params.as_no_junction(params.count()-1, "file name must not be code");          const String& first_arg=params.as_string(0, "first argument must not be code");
           size_t param_index=1;
   
           bool do_append=false;
           bool output_column_names=true;
   
           // mode?
           if(first_arg=="append")
                   do_append=true;
           else if(first_arg=="nameless")
                   output_column_names=false;
           else
                   --param_index;
   
           const String& file_name=params.as_string(param_index++, "file name must not be code");
   
           TableSeparators separators;
           if(param_index<params.count()) {
                   if(HashStringValue *options=params.as_no_junction(param_index++, "additional params must be hash").get_hash()) {
                           int valid_options=separators.load(*options);
                           if(valid_options!=options->count())
                                   throw Exception("parser.runtime",
                                           0,
                                           "invalid option passed");
                   } else
                           throw Exception("parser.runtime",
                                   0,
                                   "additional params must be hash (did you spell mode parameter correctly?)");
                   
           }
           if(param_index<params.count())
                   throw Exception("parser.runtime",
                           0,
                           "bad mode (must be nameless or append)");
   
         Table& table=GET_SELF(r, VTable).table();          Table& table=GET_SELF(r, VTable).table();
   
         bool do_append=false;  
         String sdata;          String sdata;
         if(params.count()==1) { // named output          if(output_column_names) {
                 // write out names line  
                 if(table.columns()) { // named table                  if(table.columns()) { // named table
                         for(Array_iterator<const String*> i(*table.columns()); i.has_next(); ) {                          for(Array_iterator<const String*> i(*table.columns()); i.has_next(); ) {
                                 sdata.append(*i.next(), String::L_TABLE);                                  maybe_enclose( sdata, *i.next(), separators.encloser, separators.sencloser );
                                 if(i.has_next())                                  if(i.has_next())
                                         sdata.append_know_length("\t", 1, String::L_CLEAN);                                          sdata<<*separators.scolumn;
                         }                          }
                 } else { // nameless table                  } else { // nameless table [we were asked to output column names]
                         if(int lsize=table.count()?table[0]->count():0)                          if(int lsize=table.count()?table[0]->count():0)
                                 for(int column=0; column<lsize; column++) {                                  for(int column=0; column<lsize; column++) {
                                         char *cindex_tab=new(PointerFreeGC) char[MAX_NUMBER];                                          char *cindex_tab=new(PointerFreeGC) char[MAX_NUMBER];
                                         sdata.append_know_length(cindex_tab,                                           sdata.append_know_length(cindex_tab, 
                                                 snprintf(cindex_tab, MAX_NUMBER,                                                   snprintf(cindex_tab, MAX_NUMBER, 
                                                         column<lsize-1?"%d\t":"%d", column),                                                          column<lsize-1?"%d%c":"%d", column, separators.column),
                                                         String::L_CLEAN);                                                          String::L_CLEAN);
                                 }                                  }
                         else                          else
                                 sdata.append_help_length("empty nameless table", 0, String::L_CLEAN);                                  sdata.append_help_length("empty nameless table", 0, String::L_CLEAN);
                 }                  }
                 sdata.append_know_length("\n", 1, String::L_CLEAN);                  sdata.append_know_length("\n", 1, String::L_CLEAN);
         } else { // mode specified  
                 const String&  mode=params.as_string(0, "mode must be string");  
                 if(mode=="append")  
                         do_append=true;  
                 else if(mode=="nameless")  
                         /*ok, already skipped names output*/;  
                 else  
                         throw Exception("parser.runtime",  
                                 &mode,  
                                 "unknown mode, must be 'append'");  
   
         }          }
   
         // data lines          // data lines
         Array_iterator<ArrayString*> i(table);          Array_iterator<ArrayString*> i(table);
         while(i.has_next()) {          while(i.has_next()) {
                 for(Array_iterator<const String*> c(*i.next()); c.has_next(); ) {                  for(Array_iterator<const String*> c(*i.next()); c.has_next(); ) {
                         sdata.append(*c.next(), String::L_TABLE);                          maybe_enclose( sdata, *c.next(), separators.encloser, separators.sencloser );
                         if(c.has_next())                          if(c.has_next())
                                 sdata.append_know_length("\t", 1, String::L_CLEAN);                                  sdata<<*separators.scolumn;
                 }                  }
                 sdata.append_know_length("\n", 1, String::L_CLEAN);                  sdata.append_know_length("\n", 1, String::L_CLEAN);
         }          }
   
         // write          // write
         file_write(r.absolute(vfile_name.as_string()),           {
                 sdata.cstr(), sdata.length(), true, do_append);                  const char* data_cstr=sdata.cstr();
                   file_write(r.absolute(file_name), 
                           data_cstr, sdata.length(), true, do_append);
                   if(*data_cstr) // not empty (when empty it's not heap memory)
                           pa_free((void*)data_cstr); // not needed anymore
           }
 }  }
   
 static void _count(Request& r, MethodParams&) {  static void _count(Request& r, MethodParams&) {
Line 462  static void _offset(Request& r, MethodPa Line 482  static void _offset(Request& r, MethodPa
                                         "is invalid whence, valid are 'cur' or 'set'");                                          "is invalid whence, valid are 'cur' or 'set'");
                 }                  }
                                   
                 Value& offset_expr=params.as_junction(params.count()-1, "offset must be expression");                  int offset=params.as_int(params.count()-1, "offset must be expression", r);
                 table.offset(absolute, r.process_to_value(offset_expr).as_int());                  table.offset(absolute, offset);
         } else          } else
                 r.write_no_lang(*new VInt(table.current()));                  r.write_no_lang(*new VInt(table.current()));
 }  }
Line 616  static void _hash(Request& r, MethodPara Line 636  static void _hash(Request& r, MethodPara
                                 } else                                  } else
                                         throw Exception("parser.runtime",                                          throw Exception("parser.runtime",
                                                 0,                                                  0,
                                                 "value field(s) must be string or self_table"                                                  "value field(s) must be string or table"
                                         );                                          );
                         } else { // by all columns, including key                          } else { // by all columns, including key
                                 if(!(distinct!=D_ILLEGAL && distinct!=D_FIRST))                                  if(!(distinct!=D_ILLEGAL && distinct!=D_FIRST))
Line 626  static void _hash(Request& r, MethodPara Line 646  static void _hash(Request& r, MethodPara
   
   
                         {                          {
                                 Row_info info={0};  
                                 info.r=&r;  
                                 info.table=&self_table;  
                                 Value* key_param=&params[0];                                  Value* key_param=&params[0];
                                 info.key_code=key_param->get_junction()?key_param:0;                                  Row_info info={
                                 info.key_field=info.key_code?-1                                          &r,
                                         :self_table.column_name2index(key_param->as_string(), true);                                          &self_table,
                                 info.value_fields=&value_fields;                                          /*key_code=*/key_param->get_junction()?key_param:0,
                                 info.hash=&result.hash();                                          /*key_field=*/0/*filled below*/,
                                 info.distinct=distinct;                                          &value_fields,
                                 info.row=0;                                          &result.hash(),
                                           distinct,
                                           /*row=*/0
                                   };
                                   info.key_field=(info.key_code?-1
                                                   :self_table.column_name2index(key_param->as_string(), true));
   
                                 int saved_current=self_table.current();                                  int saved_current=self_table.current();
                                 self_table.for_each(table_row_to_hash, &info);                                  self_table.for_each(table_row_to_hash, &info);
                                 self_table.set_current(saved_current);                                  self_table.set_current(saved_current);
   
                                   result.extract_default();
                         }                          }
                 }                  }
         r.write_no_lang(result);          r.write_no_lang(result);
Line 720  struct Expression_is_true_info { Line 744  struct Expression_is_true_info {
         Value* expression_code;          Value* expression_code;
 };  };
 #endif  #endif
 static bool expression_is_true(Table& self, void* ainfo) {  static bool expression_is_true(Table&, Expression_is_true_info* info) {
         Expression_is_true_info& info=*static_cast<Expression_is_true_info*>(ainfo);          return info->r->process_to_value(*info->expression_code).as_bool();
         return info.r->process_to_value(*info.expression_code).as_bool();  
 }  }
 static bool _locate_expression(Table& table, Table::Action_options o,  static bool _locate_expression(Table& table, Table::Action_options o,
                                Request& r, MethodParams& params) {                                 Request& r, MethodParams& params) {
Line 734  static bool _locate_expression(Table& ta Line 757  static bool _locate_expression(Table& ta
         return table.table_first_that(expression_is_true, &info, o);          return table.table_first_that(expression_is_true, &info, o);
 }  }
 static bool _locate_name_value(Table& table, Table::Action_options o,  static bool _locate_name_value(Table& table, Table::Action_options o,
                                Request& r, MethodParams& params) {                                 Request&, MethodParams& params) {
         check_option_param(o.defined, params, 2,          check_option_param(o.defined, params, 2,
                 "locate by locate by name has parameters: name, value and, maybe, options");                  "locate by locate by name has parameters: name, value and, maybe, options");
         const String& name=params.as_string(0, "column name must be string");          const String& name=params.as_string(0, "column name must be string");
Line 753  static void _locate(Request& r, MethodPa Line 776  static void _locate(Request& r, MethodPa
 }  }
   
   
 static void _flip(Request& r, MethodParams& params) {  static void _flip(Request& r, MethodParams&) {
         Table& old_table=GET_SELF(r, VTable).table();          Table& old_table=GET_SELF(r, VTable).table();
         Table& new_table=*new Table(0);          Table& new_table=*new Table(0);
         if(size_t old_count=old_table.count())          if(size_t old_count=old_table.count())
Line 814  static void _join(Request& r, MethodPara Line 837  static void _join(Request& r, MethodPara
                         0,                           0, 
                         "source and destination are same table");                          "source and destination are same table");
   
         if(Table::columns_type dest_columns=dest.columns()) // dest is named          if(dest.columns()) // dest is named
                 src.table_for_each(join_named_row, &dest, o);                  src.table_for_each(join_named_row, &dest, o);
         else // dest is nameless          else // dest is nameless
                 src.table_for_each(join_nameless_row, &dest, o);                  src.table_for_each(join_nameless_row, &dest, o);
Line 823  static void _join(Request& r, MethodPara Line 846  static void _join(Request& r, MethodPara
 #ifndef DOXYGEN  #ifndef DOXYGEN
 class Table_sql_event_handlers: public SQL_Driver_query_event_handlers {  class Table_sql_event_handlers: public SQL_Driver_query_event_handlers {
         ArrayString& columns;          ArrayString& columns;
           int columns_count;
         ArrayString* row;          ArrayString* row;
 public:  public:
         Table* table;          Table* table;
Line 843  public: Line 867  public:
         bool before_rows(SQL_Error& error) {           bool before_rows(SQL_Error& error) { 
                 try {                  try {
                         table=new Table(&columns);                          table=new Table(&columns);
                           columns_count=columns.count();
                         return false;                          return false;
                 } catch(...) {                  } catch(...) {
                         error=SQL_Error("exception occured in Table_sql_event_handlers::before_rows");                          error=SQL_Error("exception occured in Table_sql_event_handlers::before_rows");
Line 851  public: Line 876  public:
         }          }
         bool add_row(SQL_Error& error) {          bool add_row(SQL_Error& error) {
                 try {                  try {
                         *table+=row=new ArrayString;                          *table+=row=new ArrayString(columns_count);
                         return false;                          return false;
                 } catch(...) {                  } catch(...) {
                         error=SQL_Error("exception occured in Table_sql_event_handlers::add_row");                          error=SQL_Error("exception occured in Table_sql_event_handlers::add_row");
Line 872  public: Line 897  public:
         }          }
 };  };
 #endif  #endif
   
   static void marshal_bind(
                                                    HashStringValue::key_type aname, 
                                                    HashStringValue::value_type avalue,
                                                    SQL_Driver::Placeholder** pptr) 
   {
           SQL_Driver::Placeholder& ph=**pptr;
           ph.name=aname.cstr();
           ph.value=avalue->as_string().cstr(String::L_UNSPECIFIED);
           ph.is_null=avalue->get_class()==void_class;
           ph.were_updated=false;
   
           (*pptr)++;
   }
   
   // not static, used elsewhere
   int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders) {
           int hash_count=hash.count();
           placeholders=new(UseGC) SQL_Driver::Placeholder[hash_count];
           SQL_Driver::Placeholder* ptr=placeholders;
           hash.for_each(marshal_bind, &ptr);
           return hash_count;
   }
   
   // not static, used elsewhere
   void unmarshal_bind_updates(HashStringValue& hash, int placeholder_count, SQL_Driver::Placeholder* placeholders) {
           SQL_Driver::Placeholder* ph=placeholders;
           for(int i=0; i<placeholder_count; i++, ph++)
                   if(ph->were_updated) {
                           Value* value;
                           if(ph->is_null)
                                   value=new VVoid();
                           else
                                   if(ph->value)
                                           value=new VString(*new String(ph->value, 0, true/*tainted*/));
                                   else
                                           value=new VString(*new String());                                       
                           hash.put(ph->name, value);
                   }
   }
   
 static void _sql(Request& r, MethodParams& params) {  static void _sql(Request& r, MethodParams& params) {
         Value& statement=params.as_junction(0, "statement must be code");          Value& statement=params.as_junction(0, "statement must be code");
   
           HashStringValue* bind=0;
         ulong limit=0;          ulong limit=0;
         ulong offset=0;          ulong offset=0;
         if(params.count()>1) {          if(params.count()>1) {
                 Value& voptions=params.as_no_junction(1, "options must be hash, not code");                  Value& voptions=params.as_no_junction(1, "options must be hash, not code");
                 if(!voptions.is_string())                  if(voptions.is_defined() && !voptions.is_string())
                         if(HashStringValue* options=voptions.get_hash()) {                          if(HashStringValue* options=voptions.get_hash()) {
                                 int valid_options=0;                                  int valid_options=0;
                                   if(Value* vbind=options->get(sql_bind_name)) {
                                           valid_options++;
                                           bind=vbind->get_hash();
                                   }
                                 if(Value* vlimit=options->get(sql_limit_name)) {                                  if(Value* vlimit=options->get(sql_limit_name)) {
                                         valid_options++;                                          valid_options++;
                                         limit=(ulong)r.process_to_value(*vlimit).as_double();                                          limit=(ulong)r.process_to_value(*vlimit).as_double();
Line 900  static void _sql(Request& r, MethodParam Line 971  static void _sql(Request& r, MethodParam
                                         "options must be hash");                                          "options must be hash");
         }          }
   
           SQL_Driver::Placeholder* placeholders=0;
           uint placeholders_count=0;
           if(bind)
                   placeholders_count=marshal_binds(*bind, placeholders);
   
         Temp_lang temp_lang(r, String::L_SQL);          Temp_lang temp_lang(r, String::L_SQL);
         const String&  statement_string=r.process_to_string(statement);          const String&  statement_string=r.process_to_string(statement);
         const char* statement_cstr=          const char* statement_cstr=
Line 911  static void _sql(Request& r, MethodParam Line 987  static void _sql(Request& r, MethodParam
         gettimeofday(&mt[0],NULL);          gettimeofday(&mt[0],NULL);
 #endif    #endif  
         r.connection()->query(          r.connection()->query(
                 statement_cstr, offset, limit,                   statement_cstr, 
                   placeholders_count, placeholders,
                   offset, limit, 
                 handlers,                  handlers,
                 statement_string);                  statement_string);
                   
Line 926  static void _sql(Request& r, MethodParam Line 1004  static void _sql(Request& r, MethodParam
         r.sql_request_time+=t[1]-t[0];          r.sql_request_time+=t[1]-t[0];
 #endif                            #endif                          
   
           if(bind)
                   unmarshal_bind_updates(*bind, placeholders_count, placeholders);
   
         Table& result=          Table& result=
                 handlers.table?*handlers.table: // query resulted in table? return it                  handlers.table?*handlers.table: // query resulted in table? return it
                 *new Table(Table::columns_type(0)); // query returned no table, fake it                  *new Table(Table::columns_type(0)); // query returned no table, fake it
Line 964  static void _select(Request& r, MethodPa Line 1045  static void _select(Request& r, MethodPa
                 source_table.set_current(row);                  source_table.set_current(row);
   
                 bool condition=r.process_to_value(vcondition,                   bool condition=r.process_to_value(vcondition, 
                                 /*0/*no name* /,*/  
                                 false/*don't intercept string*/).as_bool();                                  false/*don't intercept string*/).as_bool();
   
                 if(condition) // ...condition is true=                  if(condition) // ...condition is true=
Line 991  MTable::MTable(): Methoded("table") { Line 1071  MTable::MTable(): Methoded("table") {
   
         // ^table.save[file]            // ^table.save[file]  
         // ^table.save[nameless;file]          // ^table.save[nameless;file]
         add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);          add_native_method("save", Method::CT_DYNAMIC, _save, 1, 3);
   
         // ^table.count[]          // ^table.count[]
         add_native_method("count", Method::CT_DYNAMIC, _count, 0, 0);          add_native_method("count", Method::CT_DYNAMIC, _count, 0, 0);
Removed from v.1.187  
changed lines
  Added in v.1.219

E-mail: