Need help in improving performance of prorating quantities to stores for existing orders

Question

I have a code written to allocate quantities to stores for an existing order. Suppose there is a supplier order with quantity of 100 and this needs to distributed among 4 stores which has a demand of 50,40,30 and 20. Since total demand not equal to available quantity. the available quantity needs to be allocated to stores using an algorithm.
ALgorithm is like allocating the stores in small pieces of innersize. Innersize is nothing but
quantity within the pack of packs i.e. pack has 4 pieces and each pieces internally has 10 pieces,
this 10 is called innersize.
While allocating, each store is provided quantities of innersize first and this looping continues
until available quantity is over
Ex:
store1=10
store2=10
store3=10
store4=10
second time:
store1=10(old)+10
store2=10(old)+10
store3=10(old)+10
store4=10(old)+10--demand fulfilled
third time
store1=20(old)+10
store2=20(old)+10
-- available quantity is over and hence stopped.
My code below-
=================================================
int prorate_allocation()
  char *function = "prorate_allocation";
  long t_cnt_st;
  int t_innersize;
  int   t_qty_ordered;
  int t_cnt_lp;
  bool t_complete;
  sql_cursor alloc_cursor;
  EXEC SQL DECLARE c_order CURSOR FOR -- cursor to get orders, item in that, inner size and available qty.
  SELECT oh.order_no,
  ol.item,
  isc.inner_pack_size,
  ol.qty_ordered
  FROM ABRL_ALC_CHG_TEMP_ORDHEAD oh,
  ordloc ol,
  item_supp_country isc
  WHERE oh.order_no=ol.order_no
  AND oh.supplier=isc.supplier
  and ol.item=isc.item
  AND     EXISTS (SELECT 1 FROM abrl_alc_chg_details aacd WHERE oh.order_no=aacd.order_no)
        AND     ol.qty_ordered>0;
  char   v_order_no[10];
  char v_item[25];
  double v_innersize;
  char   v_qty_ordered[12];
  char v_alloc_no[11];
  char v_location[10];
  char v_qty_allocated[12];
  int *store_quantities;
  bool *store_processed_flag;
  EXEC SQL OPEN c_order;
  if (SQL_ERROR_FOUND)
  sprintf(err_data,"CURSOR OPEN: cursor=c_order");
  strcpy(table,"ORDHEAD, ORDLOC, ITEM_SUPP_COUNTRY");
  WRITE_ERROR(SQLCODE,function,table,err_data);
  return(-1);
  EXEC SQL ALLOCATE :alloc_cursor;
  while(1)
  EXEC SQL FETCH c_order INTO :v_order_no,
  :v_item,
  :v_innersize,
  :v_qty_ordered;
  if (SQL_ERROR_FOUND)
  sprintf(err_data,"CURSOR FETCH: cursor=c_order");
  strcpy(table,"ORDHEAD, ORDLOC, ITEM_SUPP_COUNTRY");
  WRITE_ERROR(SQLCODE,function,table,err_data);
  return(-1);
  if (NO_DATA_FOUND) break;
  t_qty_ordered     =atoi(v_qty_ordered);
  t_innersize =(int)v_innersize;
  t_cnt_lp         = t_qty_ordered/t_innersize;
  t_complete =FALSE;
  EXEC SQL SELECT COUNT(*) INTO :t_cnt_st
  FROM abrl_alc_chg_ad ad,
  alloc_header ah
  WHERE ah.alloc_no=ad.alloc_no
  AND   ah.order_no=:v_order_no
  AND   ah.item=:v_item
  AND   ad.qty_allocated!=0;
  if SQL_ERROR_FOUND
            sprintf(err_data,"SELECT: ALLOC_DETAIL, count = %s\n",t_cnt_st);
            strcpy(table,"ALLOC_DETAIL");
            WRITE_ERROR(SQLCODE,function,table,err_data);
            return(-1);
  if (t_cnt_st>0)
  store_quantities=(int *) calloc(t_cnt_st,sizeof(int));
  store_processed_flag=(bool *) calloc(t_cnt_st,sizeof(bool));
  EXEC SQL EXECUTE
  BEGIN
  OPEN :alloc_cursor FOR SELECT ad.alloc_no,
  ad.to_loc,
  ad.qty_allocated
  FROM    alloc_header ah,
  abrl_alc_chg_ad ad
  WHERE   ah.alloc_no=ad.alloc_no
  AND     ah.item=:v_item
  AND     ah.order_no=:v_order_no
  order by ad.qty_allocated desc;
  END;
  END-EXEC;
  while (t_cnt_lp>0)
  EXEC SQL WHENEVER NOT FOUND DO break;
  for(int i=0;i<t_cnt_st;i++)
  EXEC SQL FETCH :alloc_cursor INTO :v_alloc_no,
  :v_location,
  :v_qty_allocated;
  if (store_quantities[i]!=(int)v_qty_allocated)
  store_quantities[i]=store_quantities[i]+t_innersize;
  t_cnt_lp--;
  if (t_cnt_lp==0)
  EXEC SQL CLOSE :alloc_cursor;
  break;
  else
  if(store_processed_flag[i]==FALSE)
  store_processed_flag[i]=TRUE;
  t_cnt_st--;
  if (t_cnt_st==0)
  t_complete=TRUE;
  break;
  if (t_complete==TRUE && t_cnt_lp!=0)
  for (int i=0;i<t_cnt_st;i++)
  store_quantities[i]=store_quantities[i]+v_innersize;
  t_cnt_lp--;
  if (t_cnt_lp==0)
  EXEC SQL CLOSE :alloc_cursor;
  break;
  }/*END OF WHILE*/
  EXEC SQL EXECUTE
  BEGIN
  OPEN :alloc_cursor FOR SELECT ad.alloc_no,
  ad.to_loc,
  ad.qty_allocated
  FROM    alloc_header ah,
  abrl_alc_chg_ad ad
  WHERE   ah.alloc_no=ad.alloc_no
  AND     ah.item=:v_item
  AND     ah.order_no=:v_order_no
  order by ad.qty_allocated desc;
  END;
  END-EXEC;
  EXEC SQL WHENEVER NOT FOUND DO break;
  for (int i=0;i<t_cnt_st;i++)
  EXEC SQL FETCH :alloc_cursor INTO :v_alloc_no,
  :v_location,
  :v_qty_allocated;
  EXEC SQL UPDATE abrl_alc_chg_ad
  SET qty_allocated=:store_quantities[i]
  WHERE to_loc=:v_location
  AND   alloc_no=:v_alloc_no;
  if SQL_ERROR_FOUND
  sprintf(err_data,"UPDATE: ALLOC_DETAIL, location = %s , alloc_no =%s\n", v_location,v_alloc_no);
  strcpy(table,"ALLOC_DETAIL");
  WRITE_ERROR(SQLCODE,function,table,err_data);
  return(-1);
  EXEC SQL UPDATE ABRL_ALC_CHG_DETAILS
  SET PROCESSED='Y'
  WHERE LOCATION=:v_location
  AND   alloc_no=:v_alloc_no
  AND PROCESSED IN ('E','U');
  if SQL_ERROR_FOUND
  sprintf(err_data,"UPDATE: ABRL_ALC_CHG_DETAILS, location = %s , alloc_no =%s\n", v_location,v_alloc_no);
  strcpy(table,"ABRL_ALC_CHG_DETAILS");
  WRITE_ERROR(SQLCODE,function,table,err_data);
  return(-1);
  EXEC SQL COMMIT;
  EXEC SQL CLOSE :alloc_cursor;
  free(store_quantities);
  free(store_processed_flag);
  }/*END OF IF*/
  }/*END OF OUTER WHILE LOOP*/
  EXEC SQL CLOSE c_order;
  if SQL_ERROR_FOUND
  sprintf(err_data,"CURSOR CLOSE: cursor = c_order");
  strcpy(table,"ORDHEAD, ORDLOC, ITEM_SUPP_COUNTRY");
  WRITE_ERROR(SQLCODE,function,table,err_data);
  return(-1);
return(0);
} /* end prorate_allocation*/

Answer 1

I have a code written to allocate quantities to stores for an existing order. Suppose there is a supplier order with quantity of 100 and this needs to distributed among 4 stores which has a demand of 50,40,30 and 20. Since total demand not equal to available quantity. the available quantity needs to be allocated to stores using an algorithm.
ALgorithm is like allocating the stores in small pieces of innersize. Innersize is nothing but
quantity within the pack of packs i.e. pack has 4 pieces and each pieces internally has 10 pieces,
this 10 is called innersize.
While allocating, each store is provided quantities of innersize first and this looping continues
until available quantity is over
Ex:
store1=10
store2=10
store3=10
store4=10
second time:
store1=10(old)+10
store2=10(old)+10
store3=10(old)+10
store4=10(old)+10--demand fulfilled
third time
store1=20(old)+10
store2=20(old)+10
-- available quantity is over and hence stopped.
My code below-
=================================================
int prorate_allocation()
  char *function = "prorate_allocation";
  long t_cnt_st;
  int t_innersize;
  int   t_qty_ordered;
  int t_cnt_lp;
  bool t_complete;
  sql_cursor alloc_cursor;
  EXEC SQL DECLARE c_order CURSOR FOR -- cursor to get orders, item in that, inner size and available qty.
  SELECT oh.order_no,
  ol.item,
  isc.inner_pack_size,
  ol.qty_ordered
  FROM ABRL_ALC_CHG_TEMP_ORDHEAD oh,
  ordloc ol,
  item_supp_country isc
  WHERE oh.order_no=ol.order_no
  AND oh.supplier=isc.supplier
  and ol.item=isc.item
  AND     EXISTS (SELECT 1 FROM abrl_alc_chg_details aacd WHERE oh.order_no=aacd.order_no)
        AND     ol.qty_ordered>0;
  char   v_order_no[10];
  char v_item[25];
  double v_innersize;
  char   v_qty_ordered[12];
  char v_alloc_no[11];
  char v_location[10];
  char v_qty_allocated[12];
  int *store_quantities;
  bool *store_processed_flag;
  EXEC SQL OPEN c_order;
  if (SQL_ERROR_FOUND)
  sprintf(err_data,"CURSOR OPEN: cursor=c_order");
  strcpy(table,"ORDHEAD, ORDLOC, ITEM_SUPP_COUNTRY");
  WRITE_ERROR(SQLCODE,function,table,err_data);
  return(-1);
  EXEC SQL ALLOCATE :alloc_cursor;
  while(1)
  EXEC SQL FETCH c_order INTO :v_order_no,
  :v_item,
  :v_innersize,
  :v_qty_ordered;
  if (SQL_ERROR_FOUND)
  sprintf(err_data,"CURSOR FETCH: cursor=c_order");
  strcpy(table,"ORDHEAD, ORDLOC, ITEM_SUPP_COUNTRY");
  WRITE_ERROR(SQLCODE,function,table,err_data);
  return(-1);
  if (NO_DATA_FOUND) break;
  t_qty_ordered     =atoi(v_qty_ordered);
  t_innersize =(int)v_innersize;
  t_cnt_lp         = t_qty_ordered/t_innersize;
  t_complete =FALSE;
  EXEC SQL SELECT COUNT(*) INTO :t_cnt_st
  FROM abrl_alc_chg_ad ad,
  alloc_header ah
  WHERE ah.alloc_no=ad.alloc_no
  AND   ah.order_no=:v_order_no
  AND   ah.item=:v_item
  AND   ad.qty_allocated!=0;
  if SQL_ERROR_FOUND
            sprintf(err_data,"SELECT: ALLOC_DETAIL, count = %s\n",t_cnt_st);
            strcpy(table,"ALLOC_DETAIL");
            WRITE_ERROR(SQLCODE,function,table,err_data);
            return(-1);
  if (t_cnt_st>0)
  store_quantities=(int *) calloc(t_cnt_st,sizeof(int));
  store_processed_flag=(bool *) calloc(t_cnt_st,sizeof(bool));
  EXEC SQL EXECUTE
  BEGIN
  OPEN :alloc_cursor FOR SELECT ad.alloc_no,
  ad.to_loc,
  ad.qty_allocated
  FROM    alloc_header ah,
  abrl_alc_chg_ad ad
  WHERE   ah.alloc_no=ad.alloc_no
  AND     ah.item=:v_item
  AND     ah.order_no=:v_order_no
  order by ad.qty_allocated desc;
  END;
  END-EXEC;
  while (t_cnt_lp>0)
  EXEC SQL WHENEVER NOT FOUND DO break;
  for(int i=0;i<t_cnt_st;i++)
  EXEC SQL FETCH :alloc_cursor INTO :v_alloc_no,
  :v_location,
  :v_qty_allocated;
  if (store_quantities[i]!=(int)v_qty_allocated)
  store_quantities[i]=store_quantities[i]+t_innersize;
  t_cnt_lp--;
  if (t_cnt_lp==0)
  EXEC SQL CLOSE :alloc_cursor;
  break;
  else
  if(store_processed_flag[i]==FALSE)
  store_processed_flag[i]=TRUE;
  t_cnt_st--;
  if (t_cnt_st==0)
  t_complete=TRUE;
  break;
  if (t_complete==TRUE && t_cnt_lp!=0)
  for (int i=0;i<t_cnt_st;i++)
  store_quantities[i]=store_quantities[i]+v_innersize;
  t_cnt_lp--;
  if (t_cnt_lp==0)
  EXEC SQL CLOSE :alloc_cursor;
  break;
  }/*END OF WHILE*/
  EXEC SQL EXECUTE
  BEGIN
  OPEN :alloc_cursor FOR SELECT ad.alloc_no,
  ad.to_loc,
  ad.qty_allocated
  FROM    alloc_header ah,
  abrl_alc_chg_ad ad
  WHERE   ah.alloc_no=ad.alloc_no
  AND     ah.item=:v_item
  AND     ah.order_no=:v_order_no
  order by ad.qty_allocated desc;
  END;
  END-EXEC;
  EXEC SQL WHENEVER NOT FOUND DO break;
  for (int i=0;i<t_cnt_st;i++)
  EXEC SQL FETCH :alloc_cursor INTO :v_alloc_no,
  :v_location,
  :v_qty_allocated;
  EXEC SQL UPDATE abrl_alc_chg_ad
  SET qty_allocated=:store_quantities[i]
  WHERE to_loc=:v_location
  AND   alloc_no=:v_alloc_no;
  if SQL_ERROR_FOUND
  sprintf(err_data,"UPDATE: ALLOC_DETAIL, location = %s , alloc_no =%s\n", v_location,v_alloc_no);
  strcpy(table,"ALLOC_DETAIL");
  WRITE_ERROR(SQLCODE,function,table,err_data);
  return(-1);
  EXEC SQL UPDATE ABRL_ALC_CHG_DETAILS
  SET PROCESSED='Y'
  WHERE LOCATION=:v_location
  AND   alloc_no=:v_alloc_no
  AND PROCESSED IN ('E','U');
  if SQL_ERROR_FOUND
  sprintf(err_data,"UPDATE: ABRL_ALC_CHG_DETAILS, location = %s , alloc_no =%s\n", v_location,v_alloc_no);
  strcpy(table,"ABRL_ALC_CHG_DETAILS");
  WRITE_ERROR(SQLCODE,function,table,err_data);
  return(-1);
  EXEC SQL COMMIT;
  EXEC SQL CLOSE :alloc_cursor;
  free(store_quantities);
  free(store_processed_flag);
  }/*END OF IF*/
  }/*END OF OUTER WHILE LOOP*/
  EXEC SQL CLOSE c_order;
  if SQL_ERROR_FOUND
  sprintf(err_data,"CURSOR CLOSE: cursor = c_order");
  strcpy(table,"ORDHEAD, ORDLOC, ITEM_SUPP_COUNTRY");
  WRITE_ERROR(SQLCODE,function,table,err_data);
  return(-1);
return(0);
} /* end prorate_allocation*/