1. Summary
  2. Files
  3. Support
  4. Report Spam
  5. Create account
  6. Log in

Changeset 11133

Show
Ignore:
Timestamp:
05/23/13 20:23:29 (11 months ago)
Author:
cubridengine
Message:

[CUBRIDSUS-6723][CR] additional leak fix; 4th

Location:
cubridengine/trunk/src
Files:
8 modified

Legend:

Unmodified
Added
Removed
  • cubridengine/trunk/src/object/object_domain.c

    r10686 r11133  
    78697869                                              do_domain_select, false); 
    78707870              } 
     7871            (void) pr_clear_value (&tmpval); 
    78717872          } 
    78727873          break; 
     
    84508451          case DB_TYPE_CLOB: 
    84518452            { 
    8452               DB_VALUE val; 
    84538453              status = 
    8454                 tp_value_cast_internal (src, &val, 
     8454                tp_value_cast_internal (src, &conv_val, 
    84558455                                        tp_domain_resolve_default 
    84568456                                        (DB_TYPE_STRING), coercion_mode, 
     
    84588458              if (status == DOMAIN_COMPATIBLE) 
    84598459                { 
    8460                   val_str = DB_GET_STRING (&val); 
    8461                   val_str_size = DB_GET_STRING_SIZE (&val); 
    8462                   alloc_string = !val.need_clear; 
    8463                   /* we will steal the string value from val and we do not 
    8464                    * want somebody else to call pr_clear_value on val 
    8465                    */ 
    8466                   val.need_clear = false; 
     8460                  val_str = DB_GET_STRING (&conv_val); 
     8461                  val_str_size = DB_GET_STRING_SIZE (&conv_val); 
    84678462                } 
    84688463            } 
  • cubridengine/trunk/src/object/object_primitive.c

    r10465 r11133  
    56445644              db_private_free_and_init (NULL, e); 
    56455645            } 
     5646 
     5647          value->need_clear = true; 
    56465648        } 
    56475649      else 
  • cubridengine/trunk/src/query/query_executor.c

    r11093 r11133  
    18711871       * (ie, select set{} from ...) is executed under asynchronous mode. 
    18721872       */ 
    1873       if (!XASL_IS_FLAGED (xasl_p, XASL_QEXEC_MODE_ASYNC)) 
     1873      if (!XASL_IS_FLAGED (xasl_p, XASL_QEXEC_MODE_ASYNC) 
     1874          && !XASL_IS_FLAGED (xasl_p, XASL_KEEP_DBVAL)) 
    18741875        { 
    18751876          pr_clear_value (&regu_var->value.dbval); 
     
    28422843 
    28432844  pg_cnt = 0; 
    2844   if (!XASL_IS_FLAGED (xasl_p, XASL_QEXEC_MODE_ASYNC)) 
     2845  if (!XASL_IS_FLAGED (xasl_p, XASL_QEXEC_MODE_ASYNC) 
     2846      && !XASL_IS_FLAGED (xasl_p, XASL_KEEP_DBVAL)) 
    28452847    { 
    28462848      pr_clear_value (assignment->constant); 
     
    38133815  /* cleanup rollup aggregates lists */ 
    38143816  qexec_clear_groupby_rollup (thread_p, gbstate); 
     3817 
     3818  if (gbstate->composite_lock) 
     3819    { 
     3820      /* TODO - return error handling */ 
     3821      (void) lock_finalize_composite_lock (thread_p, gbstate->composite_lock); 
     3822    } 
    38153823} 
    38163824 
     
    1847318481          if (i >= rollup_level) 
    1847418482            { 
     18483              (void) pr_clear_value (gby_vallist->val); 
    1847518484              DB_MAKE_NULL (gby_vallist->val); 
    1847618485            } 
     
    2175621765  if (!dealloc_dbvalues) 
    2175721766    { 
    21758       XASL_SET_FLAG (&xasl_node, XASL_QEXEC_MODE_ASYNC); 
     21767      XASL_SET_FLAG (&xasl_node, XASL_KEEP_DBVAL); 
    2175921768    } 
    2176021769 
  • cubridengine/trunk/src/query/query_executor.h

    r10934 r11133  
    691691#define XASL_IS_MERGE_QUERY           2048      /* query belongs to a merge statement */ 
    692692#define XASL_USES_MRO         4096      /* query uses multi range optimization */ 
     693#define XASL_KEEP_DBVAL       8192      /* do not clear db_value */ 
    693694 
    694695#define XASL_IS_FLAGED(x, f)        ((x)->flag & (int) (f)) 
  • cubridengine/trunk/src/query/query_opfunc.c

    r11093 r11133  
    471471 
    472472  /* clear any value from a previous iteration */ 
    473   pr_clear_value (dest_p); 
     473  (void) pr_clear_value (dest_p); 
    474474 
    475475  src_type = DB_VALUE_DOMAIN_TYPE (src_p); 
     
    89588958              goto error; 
    89598959            } 
     8960          result_p->need_clear = true; 
    89608961        } 
    89618962      else 
     
    96599660    case PT_LAG: 
    96609661      /* just copy */ 
    9661       pr_clear_value (func_p->value); 
     9662      (void) pr_clear_value (func_p->value); 
    96629663      pr_clone_value (&dbval, func_p->value); 
    96639664      break; 
     
    96749675    case PT_NTH_VALUE: 
    96759676      /* just copy */ 
    9676       pr_clear_value (func_p->value); 
     9677      (void) pr_clear_value (func_p->value); 
    96779678      pr_clone_value (&dbval, func_p->value); 
    96789679      break; 
     
    98329833            } 
    98339834 
    9834           pr_clear_value (func_p->value); 
    9835           pr_clear_value (func_p->value2); 
     9835          (void) pr_clear_value (func_p->value); 
     9836          (void) pr_clear_value (func_p->value2); 
    98369837          dbval_type = DB_VALUE_DOMAIN_TYPE (func_p->value); 
    98379838          pr_type_p = PR_TYPE_FROM_ID (dbval_type); 
     
    99979998    { 
    99989999      /* copy resultant operand value to analytic node */ 
    9999       pr_clear_value (func_p->value); 
     10000      (void) pr_clear_value (func_p->value); 
    1000010001      dbval_type = DB_VALUE_DOMAIN_TYPE (func_p->value); 
    1000110002      pr_type_p = PR_TYPE_FROM_ID (dbval_type); 
  • cubridengine/trunk/src/query/string_opfunc.c

    r10686 r11133  
    11481148  int error_status = NO_ERROR; 
    11491149  DB_TYPE string_type1, string_type2; 
     1150  bool is_inplace_concat; 
    11501151 
    11511152  /* 
     
    11601161  assert (string2 != (DB_VALUE *) NULL); 
    11611162  assert (result != (DB_VALUE *) NULL); 
     1163 
     1164  is_inplace_concat = false;    /* init */ 
     1165 
     1166  /* check iff is in-place update */ 
     1167  if (string1 == result || string2 == result) 
     1168    { 
     1169      is_inplace_concat = true; 
     1170    } 
    11621171 
    11631172  /* 
     
    14281437                                              DB_VALUE_PRECISION (string1) + 
    14291438                                              DB_VALUE_PRECISION (string2)); 
     1439                } 
     1440 
     1441              if (is_inplace_concat) 
     1442                { 
     1443                  /* clear value before in-place update */ 
     1444                  (void) pr_clear_value (result); 
    14301445                } 
    14311446 
  • cubridengine/trunk/src/thread/thread.c

    r10852 r11133  
    36763676      for (i = 0; i < RC_LAST; i++) 
    36773677        { 
     3678#if 1                           /* TODO - remove me someday */ 
    36783679          /* TODO: Currently, skip out Memory leak check for the 1st-Track */ 
    36793680          if (id <= 0) 
     
    36843685                } 
    36853686            } 
     3687#endif 
    36863688 
    36873689          /* skip out pgbuf_temp check; is included with pgbuf check */ 
     
    42484250            } 
    42494251          fprintf (outfp, "\n"); 
    4250           fprintf (outfp, "         +--- add_buf_size = %d\n", 
     4252          fprintf (outfp, "            +--- add_buf_size = %d\n", 
    42514253                   meter->m_add_buf_size); 
    42524254        } 
     
    42594261            } 
    42604262          fprintf (outfp, "\n"); 
    4261           fprintf (outfp, "         +--- sub_buf_size = %d\n", 
     4263          fprintf (outfp, "            +--- sub_buf_size = %d\n", 
    42624264                   meter->m_sub_buf_size); 
    42634265        } 
  • cubridengine/trunk/src/transaction/lock_manager.c

    r10706 r11133  
    1114511145  OID *p; 
    1114611146  int max_oids; 
     11147  bool need_free; 
     11148  int ret = NO_ERROR; 
     11149 
     11150  need_free = false;            /* init */ 
    1114711151 
    1114811152  lockcomp = &(comp_lock->lockcomp); 
     
    1115511159        } 
    1115611160    } 
     11161 
    1115711162  if (lockcomp_class == NULL) 
    1115811163    {                           /* class is not found */ 
     
    1116311168      if (lockcomp_class == NULL) 
    1116411169        { 
    11165           return ER_OUT_OF_VIRTUAL_MEMORY; 
    11166         } 
     11170          ret = ER_OUT_OF_VIRTUAL_MEMORY; 
     11171          goto exit_on_error; 
     11172        } 
     11173 
     11174      need_free = true; 
     11175 
     11176      lockcomp_class->inst_oid_space = NULL;    /* init */ 
    1116711177 
    1116811178      if (lockcomp->root_class_ptr == NULL) 
     
    1117111181            lock_get_class_lock (oid_Root_class_oid, lockcomp->tran_index); 
    1117211182        } 
     11183 
    1117311184      /* initialize lockcomp_class */ 
    1117411185      COPY_OID (&lockcomp_class->class_oid, class_oid); 
     
    1118011191          != LK_GRANTED) 
    1118111192        { 
    11182           db_private_free_and_init (thread_p, lockcomp_class); 
    11183           return ER_FAILED; 
    11184         } 
     11193          ret = ER_FAILED; 
     11194          goto exit_on_error; 
     11195        } 
     11196 
    1118511197      if (lockcomp_class->class_lock_ptr->granted_mode == X_LOCK) 
    1118611198        { 
     
    1119911211                prm_get_integer_value (PRM_ID_LK_ESCALATION_AT); 
    1120011212            } 
     11213 
    1120111214          lockcomp_class->inst_oid_space = 
    1120211215            (OID *) db_private_alloc (thread_p, 
     
    1120511218          if (lockcomp_class->inst_oid_space == NULL) 
    1120611219            { 
    11207               db_private_free_and_init (thread_p, lockcomp_class); 
    11208               return ER_OUT_OF_VIRTUAL_MEMORY; 
     11220              ret = ER_OUT_OF_VIRTUAL_MEMORY; 
     11221              goto exit_on_error; 
    1120911222            } 
    1121011223          lockcomp_class->num_inst_oids = 0; 
     
    1121411227      lockcomp_class->next = lockcomp->class_list; 
    1121511228      lockcomp->class_list = lockcomp_class; 
     11229 
     11230      need_free = false; 
    1121611231    } 
    1121711232 
     
    1123811253                                            lockcomp_class->inst_oid_space, 
    1123911254                                            sizeof (OID) * max_oids); 
    11240               if (p != NULL) 
     11255              if (p == NULL) 
    1124111256                { 
    11242                   lockcomp_class->inst_oid_space = p; 
    11243                   lockcomp_class->max_inst_oids = max_oids; 
     11257                  ret = ER_OUT_OF_VIRTUAL_MEMORY; 
     11258                  goto exit_on_error; 
    1124411259                } 
    11245               else 
    11246                 { 
    11247                   return ER_OUT_OF_VIRTUAL_MEMORY; 
    11248                 } 
    11249             } 
    11250         } 
     11260 
     11261              lockcomp_class->inst_oid_space = p; 
     11262              lockcomp_class->max_inst_oids = max_oids; 
     11263            } 
     11264        } 
     11265 
    1125111266      if (lockcomp_class->num_inst_oids < lockcomp_class->max_inst_oids) 
    1125211267        { 
     
    1125911274       */ 
    1126011275    } 
    11261   return NO_ERROR; 
     11276 
     11277  assert (ret == NO_ERROR); 
     11278 
     11279end: 
     11280 
     11281  if (need_free) 
     11282    { 
     11283      if (lockcomp_class->inst_oid_space) 
     11284        { 
     11285          db_private_free_and_init (thread_p, lockcomp_class->inst_oid_space); 
     11286        } 
     11287      db_private_free_and_init (thread_p, lockcomp_class); 
     11288    } 
     11289 
     11290  return ret; 
     11291 
     11292exit_on_error: 
     11293 
     11294  assert (ret != NO_ERROR); 
     11295  if (ret == NO_ERROR) 
     11296    { 
     11297      ret = ER_FAILED; 
     11298    } 
     11299 
     11300  goto end; 
    1126211301#endif /* !SERVER_MODE */ 
    1126311302}