Precision Math implementation

BitKeeper/etc/ignore:
  Added client/decimal.c client/my_decimal.cc client/my_decimal.h to the ignore list

1 files changed, 103 insertions, 20 deletions

diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
index b5cb01494fa..8d392232f02 100644
--- a/sql/item_subselect.cc
+++ b/sql/item_subselect.cc
@@ -143,7 +143,7 @@ bool Item_subselect::fix_fields(THD *thd_param, TABLE_LIST *tables, Item **ref)
 
   res= engine->prepare();
 
-  // all transformetion is done (used by prepared statements)
+  // all transformation is done (used by prepared statements)
   changed= 1;
 
   if (!res)
@@ -246,7 +246,7 @@ void Item_subselect::update_used_tables()
 {
   if (!engine->uncacheable())
   {
-    // did all used tables become ststic?
+    // did all used tables become static?
     if (!(used_tables_cache & ~engine->upper_select_const_tables()))
       const_item_cache= 1;
   }
@@ -292,7 +292,7 @@ Item_maxmin_subselect::Item_maxmin_subselect(THD *thd_param,
   const_item_cache= parent->get_const_item_cache();
 
   /*
-    this subquery alwais creates during preparation, so we can assign
+    this subquery always creates during preparation, so we can assign
     thd here
   */
   thd= thd_param;
@@ -356,7 +356,7 @@ Item_singlerow_subselect::select_transformer(JOIN *join)
       !(select_lex->item_list.head()->type() == FIELD_ITEM ||
 	select_lex->item_list.head()->type() == REF_ITEM) &&
       /*
-        switch off this optimisation for prepare statement,
+        switch off this optimization for prepare statement,
         because we do not rollback this changes
         TODO: make rollback for it, or special name resolving mode in 5.0.
       */
@@ -374,7 +374,7 @@ Item_singlerow_subselect::select_transformer(JOIN *join)
     }
     substitution= select_lex->item_list.head();
     /*
-      as far as we moved content to upper leven, field which depend of
+      as far as we moved content to upper level, field which depend of
       'upper' select is not really dependent => we remove this dependence
     */
     substitution->walk(&Item::remove_dependence_processor,
@@ -494,7 +494,7 @@ longlong Item_singlerow_subselect::val_int()
   }
 }
 
-String *Item_singlerow_subselect::val_str (String *str)
+String *Item_singlerow_subselect::val_str(String *str)
 {
   if (!exec() && !value->null_value)
   {
@@ -509,10 +509,41 @@ String *Item_singlerow_subselect::val_str (String *str)
 }
 
 
+my_decimal *Item_singlerow_subselect::val_decimal(my_decimal *decimal_value)
+{
+  if (!exec() && !value->null_value)
+  {
+    null_value= 0;
+    return value->val_decimal(decimal_value);
+  }
+  else
+  {
+    reset();
+    return 0;
+  }
+}
+
+
+bool Item_singlerow_subselect::val_bool()
+{
+  if (!exec() && !value->null_value)
+  {
+    null_value= 0;
+    return value->val_bool();
+  }
+  else
+  {
+    reset();
+    return 0;
+  }
+}
+
+
 Item_exists_subselect::Item_exists_subselect(st_select_lex *select_lex):
   Item_subselect()
 {
   DBUG_ENTER("Item_exists_subselect::Item_exists_subselect");
+  bool val_bool();
   init(select_lex, new select_exists_subselect(this));
   max_columns= UINT_MAX;
   null_value= 0; //can't be NULL
@@ -622,6 +653,32 @@ String *Item_exists_subselect::val_str(String *str)
   return str;
 }
 
+
+my_decimal *Item_exists_subselect::val_decimal(my_decimal *decimal_value)
+{
+  DBUG_ASSERT(fixed == 1);
+  if (exec())
+  {
+    reset();
+    return 0;
+  }
+  int2my_decimal(E_DEC_FATAL_ERROR, value, 0, decimal_value);
+  return decimal_value;
+}
+
+
+bool Item_exists_subselect::val_bool()
+{
+  DBUG_ASSERT(fixed == 1);
+  if (exec())
+  {
+    reset();
+    return 0;
+  }
+  return value;
+}
+
+
 double Item_in_subselect::val_real()
 {
   DBUG_ASSERT(fixed == 1);
@@ -752,7 +809,8 @@ Item_in_subselect::single_value_transformer(JOIN *join,
 
       /*
 	Item_sum_(max|min) can't substitute other item => we can use 0 as
-	reference
+        reference, also Item_sum_(max|min) can't be fixed after creation, so
+        we do not check item->fixed
       */
       if (item->fix_fields(thd, join->tables_list, 0))
 	goto err;
@@ -774,7 +832,7 @@ Item_in_subselect::single_value_transformer(JOIN *join,
     // left expression belong to outer select
     SELECT_LEX *current= thd->lex->current_select, *up;
     thd->lex->current_select= up= current->return_after_parsing();
-    if (!left_expr->fixed && 
+    if (!left_expr->fixed &&
         left_expr->fix_fields(thd, up->get_table_list(), &left_expr))
     {
       thd->lex->current_select= current;
@@ -803,7 +861,7 @@ Item_in_subselect::single_value_transformer(JOIN *join,
     thd->lex->current_select= current;
 
     /*
-      As far as  Item_ref_in_optimizer do not substitude itself on fix_fields
+      As far as  Item_ref_in_optimizer do not substitute itself on fix_fields
       we can use same item for all selects.
     */
     expr= new Item_direct_ref((Item**)optimizer->get_cache(),
@@ -840,6 +898,10 @@ Item_in_subselect::single_value_transformer(JOIN *join,
     */
     select_lex->having= join->having= and_items(join->having, item);
     select_lex->having_fix_field= 1;
+    /*
+      we do not check join->having->fixed, because Item_and (from and_items)
+      or comparison function (from func->create) can't be fixed after creation
+    */
     tmp= join->having->fix_fields(thd, join->tables_list, 0);
     select_lex->having_fix_field= 0;
     if (tmp)
@@ -871,6 +933,11 @@ Item_in_subselect::single_value_transformer(JOIN *join,
 			 new Item_cond_and(having, join->having) :
 			 having);
 	select_lex->having_fix_field= 1;
+        /*
+          we do not check join->having->fixed, because Item_and (from
+          and_items) or comparison function (from func->create) can't be
+          fixed after creation
+        */
 	tmp= join->having->fix_fields(thd, join->tables_list, 0);
         select_lex->having_fix_field= 0;
         if (tmp)
@@ -887,6 +954,10 @@ Item_in_subselect::single_value_transformer(JOIN *join,
 	argument (reference) to fix_fields()
       */
       select_lex->where= join->conds= and_items(join->conds, item);
+      /*
+        we do not check join->conds->fixed, because Item_and can't be fixed
+        after creation
+      */
       if (join->conds->fix_fields(thd, join->tables_list, 0))
 	goto err;
     }
@@ -908,6 +979,10 @@ Item_in_subselect::single_value_transformer(JOIN *join,
           item= new Item_cond_or(new Item_func_isnull(left_expr), item);
 	select_lex->having= join->having= item;   
 	select_lex->having_fix_field= 1;
+        /*
+          we do not check join->having->fixed, because comparison function
+          (from func->create) can't be fixed after creation
+        */
 	tmp= join->having->fix_fields(thd, join->tables_list, 0);
         select_lex->having_fix_field= 0;
         if (tmp)
@@ -982,7 +1057,7 @@ Item_in_subselect::row_value_transformer(JOIN *join)
       goto err;
     }
 
-    // we will refer to apper level cache array => we have to save it in PS
+    // we will refer to upper level cache array => we have to save it in PS
     optimizer->keep_top_level_cache();
 
     thd->lex->current_select= current;
@@ -1000,9 +1075,9 @@ Item_in_subselect::row_value_transformer(JOIN *join)
           check_cols(left_expr->el(i)->cols()))
         goto err;
       Item *func= new Item_ref_null_helper(this,
-					   select_lex->ref_pointer_array+i,
-					   (char *) "<no matter>",
-					   (char *) "<list ref>");
+                                           select_lex->ref_pointer_array+i,
+                                           (char *) "<no matter>",
+                                           (char *) "<list ref>");
       func=
 	eq_creator.create(new Item_direct_ref((*optimizer->get_cache())->
 					      addr(i),
@@ -1023,6 +1098,10 @@ Item_in_subselect::row_value_transformer(JOIN *join)
     */
     select_lex->having= join->having= and_items(join->having, item);
     select_lex->having_fix_field= 1;
+    /*
+      join->having can't be fixed after creation, so we do not check
+      join->having->fixed
+    */
     if (join->having->fix_fields(thd, join->tables_list, 0))
     {
       select_lex->having_fix_field= 0;
@@ -1038,6 +1117,10 @@ Item_in_subselect::row_value_transformer(JOIN *join)
       argument (reference) to fix_fields()
     */
     select_lex->where= join->conds= and_items(join->conds, item);
+    /*
+      join->conds can't be fixed after creation, so we do not check
+      join->conds->fixed
+    */
     if (join->conds->fix_fields(thd, join->tables_list, 0))
       goto err;
   }
@@ -1533,7 +1616,7 @@ void subselect_indexsubquery_engine::print(String *str)
   str->append(" on ", 4);
   str->append(key_info->name);
   if (check_null)
-    str->append(" chicking NULL", 14);
+    str->append(" checking NULL", 14);
     if (cond)
   {
     str->append(" where ", 7);
@@ -1545,7 +1628,7 @@ void subselect_indexsubquery_engine::print(String *str)
 /*
   change select_result object of engine
 
-  SINOPSYS
+  SYNOPSIS
     subselect_single_select_engine::change_result()
     si		new subselect Item
     res		new select_result object
@@ -1567,7 +1650,7 @@ bool subselect_single_select_engine::change_result(Item_subselect *si,
 /*
   change select_result object of engine
 
-  SINOPSYS
+  SYNOPSIS
     subselect_single_select_engine::change_result()
     si		new subselect Item
     res		new select_result object
@@ -1590,7 +1673,7 @@ bool subselect_union_engine::change_result(Item_subselect *si,
 /*
   change select_result emulation, never should be called
 
-  SINOPSYS
+  SYNOPSIS
     subselect_single_select_engine::change_result()
     si		new subselect Item
     res		new select_result object
@@ -1611,7 +1694,7 @@ bool subselect_uniquesubquery_engine::change_result(Item_subselect *si,
 /*
   Report about presence of tables in subquery
 
-  SINOPSYS
+  SYNOPSIS
     subselect_single_select_engine::no_tables()
 
   RETURN
@@ -1627,7 +1710,7 @@ bool subselect_single_select_engine::no_tables()
 /*
   Report about presence of tables in subquery
 
-  SINOPSYS
+  SYNOPSIS
     subselect_union_engine::no_tables()
 
   RETURN
@@ -1648,7 +1731,7 @@ bool subselect_union_engine::no_tables()
 /*
   Report about presence of tables in subquery
 
-  SINOPSYS
+  SYNOPSIS
     subselect_uniquesubquery_engine::no_tables()
 
   RETURN