eTRM uses javascript that opens and focuses a separate window to display reports. Your browser does not appear to support javascript. This should not prevent you from using eTRM but it does mean the window focus feature will not work. Please check the contents of other windows on your desktop if you click on a link that does not appear to do anything.

APPS.MSC_ATP_PF dependencies on MSC_UTIL

Line 8908: msc_util.msc_log('*Begin procedure Populate_ATF_Dates ');

8904: --bug3663487 end
8905:
8906: BEGIN
8907: IF PG_DEBUG in ('Y', 'C') THEN
8908: msc_util.msc_log('*********Begin procedure Populate_ATF_Dates ********');
8909: msc_util.msc_log('Populate_ATF_Dates: ' || 'p_plan_id = ' ||to_char(p_plan_id));
8910: END IF;
8911:
8912: -- initialize API return status to success

Line 8909: msc_util.msc_log('Populate_ATF_Dates: ' || 'p_plan_id = ' ||to_char(p_plan_id));

8905:
8906: BEGIN
8907: IF PG_DEBUG in ('Y', 'C') THEN
8908: msc_util.msc_log('*********Begin procedure Populate_ATF_Dates ********');
8909: msc_util.msc_log('Populate_ATF_Dates: ' || 'p_plan_id = ' ||to_char(p_plan_id));
8910: END IF;
8911:
8912: -- initialize API return status to success
8913: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 8953: msc_util.msc_log('Populate_ATF_Dates: ' || 'l_inventory_item_id.COUNT = ' ||l_inventory_item_id.COUNT);

8949: AND c2.calendar_code = c1.calendar_code
8950: AND c2.exception_set_id = -1;
8951:
8952: IF PG_DEBUG in ('Y', 'C') THEN
8953: msc_util.msc_log('Populate_ATF_Dates: ' || 'l_inventory_item_id.COUNT = ' ||l_inventory_item_id.COUNT);
8954: END IF;
8955:
8956: IF l_inventory_item_id IS NOT NULL AND l_inventory_item_id.COUNT > 0 THEN
8957:

Line 9049: msc_util.msc_log('Populate_ATF_Dates: ' || 'Member Count = ' ||to_char(x_member_count));

9045: );
9046: */
9047:
9048: IF PG_DEBUG in ('Y', 'C') THEN
9049: msc_util.msc_log('Populate_ATF_Dates: ' || 'Member Count = ' ||to_char(x_member_count));
9050: msc_util.msc_log('*********End of procedure Populate_ATF_Dates ********');
9051: END IF;
9052:
9053: EXCEPTION

Line 9050: msc_util.msc_log('*End of procedure Populate_ATF_Dates ');

9046: */
9047:
9048: IF PG_DEBUG in ('Y', 'C') THEN
9049: msc_util.msc_log('Populate_ATF_Dates: ' || 'Member Count = ' ||to_char(x_member_count));
9050: msc_util.msc_log('*********End of procedure Populate_ATF_Dates ********');
9051: END IF;
9052:
9053: EXCEPTION
9054: WHEN OTHERS THEN

Line 9056: msc_util.msc_log('Populate_ATF_Dates: ' || 'Exception: ' || sqlerrm);

9052:
9053: EXCEPTION
9054: WHEN OTHERS THEN
9055: IF PG_DEBUG in ('Y', 'C') THEN
9056: msc_util.msc_log('Populate_ATF_Dates: ' || 'Exception: ' || sqlerrm);
9057: msc_util.msc_log('Populate_ATF_Dates: ' || 'Error code:' || to_char(sqlcode));
9058: END IF;
9059: x_return_status := FND_API.G_RET_STS_ERROR;
9060:

Line 9057: msc_util.msc_log('Populate_ATF_Dates: ' || 'Error code:' || to_char(sqlcode));

9053: EXCEPTION
9054: WHEN OTHERS THEN
9055: IF PG_DEBUG in ('Y', 'C') THEN
9056: msc_util.msc_log('Populate_ATF_Dates: ' || 'Exception: ' || sqlerrm);
9057: msc_util.msc_log('Populate_ATF_Dates: ' || 'Error code:' || to_char(sqlcode));
9058: END IF;
9059: x_return_status := FND_API.G_RET_STS_ERROR;
9060:
9061: END Populate_ATF_Dates;

Line 9107: msc_util.msc_log('*Begin procedure Calculate_Alloc_Percentages ');

9103:
9104:
9105: BEGIN
9106: IF PG_DEBUG in ('Y', 'C') THEN
9107: msc_util.msc_log('*********Begin procedure Calculate_Alloc_Percentages ********');
9108: msc_util.msc_log('Calculate_Alloc_Percentages: ' || 'p_plan_id = ' ||to_char(p_plan_id));
9109: END IF;
9110:
9111: -- initialize API return status to success

Line 9108: msc_util.msc_log('Calculate_Alloc_Percentages: ' || 'p_plan_id = ' ||to_char(p_plan_id));

9104:
9105: BEGIN
9106: IF PG_DEBUG in ('Y', 'C') THEN
9107: msc_util.msc_log('*********Begin procedure Calculate_Alloc_Percentages ********');
9108: msc_util.msc_log('Calculate_Alloc_Percentages: ' || 'p_plan_id = ' ||to_char(p_plan_id));
9109: END IF;
9110:
9111: -- initialize API return status to success
9112: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 9170: msc_util.msc_log('Calculate_Alloc_Percentages: ' || 'Row Count in MSC_ALLOC_TEMP = '|| SQL%ROWCOUNT);

9166: where mat2.transaction_id = mat1.transaction_id
9167: );
9168:
9169: IF PG_DEBUG in ('Y', 'C') THEN
9170: msc_util.msc_log('Calculate_Alloc_Percentages: ' || 'Row Count in MSC_ALLOC_TEMP = '|| SQL%ROWCOUNT);
9171: msc_util.msc_log('*********End of procedure Calculate_Alloc_Percentages ********');
9172: END IF;
9173:
9174: EXCEPTION

Line 9171: msc_util.msc_log('*End of procedure Calculate_Alloc_Percentages ');

9167: );
9168:
9169: IF PG_DEBUG in ('Y', 'C') THEN
9170: msc_util.msc_log('Calculate_Alloc_Percentages: ' || 'Row Count in MSC_ALLOC_TEMP = '|| SQL%ROWCOUNT);
9171: msc_util.msc_log('*********End of procedure Calculate_Alloc_Percentages ********');
9172: END IF;
9173:
9174: EXCEPTION
9175: WHEN OTHERS THEN

Line 9177: msc_util.msc_log('Calculate_Alloc_Percentages: ' || 'Exception: ' || sqlerrm);

9173:
9174: EXCEPTION
9175: WHEN OTHERS THEN
9176: IF PG_DEBUG in ('Y', 'C') THEN
9177: msc_util.msc_log('Calculate_Alloc_Percentages: ' || 'Exception: ' || sqlerrm);
9178: msc_util.msc_log('Calculate_Alloc_Percentages: ' || 'Error code:' || to_char(sqlcode));
9179: END IF;
9180: x_return_status := FND_API.G_RET_STS_ERROR;
9181:

Line 9178: msc_util.msc_log('Calculate_Alloc_Percentages: ' || 'Error code:' || to_char(sqlcode));

9174: EXCEPTION
9175: WHEN OTHERS THEN
9176: IF PG_DEBUG in ('Y', 'C') THEN
9177: msc_util.msc_log('Calculate_Alloc_Percentages: ' || 'Exception: ' || sqlerrm);
9178: msc_util.msc_log('Calculate_Alloc_Percentages: ' || 'Error code:' || to_char(sqlcode));
9179: END IF;
9180: x_return_status := FND_API.G_RET_STS_ERROR;
9181:
9182: END Calculate_Alloc_Percentages;

Line 9263: msc_util.msc_log('*Begin procedure Pf_Post_Plan_Proc ');

9259: l_yes VARCHAR2(1) := 'Y';
9260: l_excess_dc VARCHAR2(30) := '-2';
9261:
9262: BEGIN
9263: msc_util.msc_log('*********Begin procedure Pf_Post_Plan_Proc ********');
9264:
9265: --project atp
9266: l_excess_supply_by_dc := NVL(FND_PROFILE.VALUE('MSC_EXCESS_SUPPLY_BY_DC'), 'N');
9267: msc_util.msc_log('l_excess_supply_by_dc := ' || l_excess_supply_by_dc);

Line 9267: msc_util.msc_log('l_excess_supply_by_dc := ' || l_excess_supply_by_dc);

9263: msc_util.msc_log('*********Begin procedure Pf_Post_Plan_Proc ********');
9264:
9265: --project atp
9266: l_excess_supply_by_dc := NVL(FND_PROFILE.VALUE('MSC_EXCESS_SUPPLY_BY_DC'), 'N');
9267: msc_util.msc_log('l_excess_supply_by_dc := ' || l_excess_supply_by_dc);
9268:
9269: BEGIN
9270: msc_util.msc_log('Calling custom procedure MSC_ATP_CUSTOM.Custom_Pre_Allocation...');
9271: MSC_ATP_CUSTOM.Custom_Pre_Allocation(p_plan_id);

Line 9270: msc_util.msc_log('Calling custom procedure MSC_ATP_CUSTOM.Custom_Pre_Allocation...');

9266: l_excess_supply_by_dc := NVL(FND_PROFILE.VALUE('MSC_EXCESS_SUPPLY_BY_DC'), 'N');
9267: msc_util.msc_log('l_excess_supply_by_dc := ' || l_excess_supply_by_dc);
9268:
9269: BEGIN
9270: msc_util.msc_log('Calling custom procedure MSC_ATP_CUSTOM.Custom_Pre_Allocation...');
9271: MSC_ATP_CUSTOM.Custom_Pre_Allocation(p_plan_id);
9272: msc_util.msc_log('End MSC_ATP_CUSTOM.Custom_Pre_Allocation.');
9273: EXCEPTION
9274: WHEN OTHERS THEN

Line 9272: msc_util.msc_log('End MSC_ATP_CUSTOM.Custom_Pre_Allocation.');

9268:
9269: BEGIN
9270: msc_util.msc_log('Calling custom procedure MSC_ATP_CUSTOM.Custom_Pre_Allocation...');
9271: MSC_ATP_CUSTOM.Custom_Pre_Allocation(p_plan_id);
9272: msc_util.msc_log('End MSC_ATP_CUSTOM.Custom_Pre_Allocation.');
9273: EXCEPTION
9274: WHEN OTHERS THEN
9275: msc_util.msc_log('Error in custom procedure call');
9276: msc_util.msc_log('Error Code: '|| sqlerrm);

Line 9275: msc_util.msc_log('Error in custom procedure call');

9271: MSC_ATP_CUSTOM.Custom_Pre_Allocation(p_plan_id);
9272: msc_util.msc_log('End MSC_ATP_CUSTOM.Custom_Pre_Allocation.');
9273: EXCEPTION
9274: WHEN OTHERS THEN
9275: msc_util.msc_log('Error in custom procedure call');
9276: msc_util.msc_log('Error Code: '|| sqlerrm);
9277: END;
9278: --project atp
9279:

Line 9276: msc_util.msc_log('Error Code: '|| sqlerrm);

9272: msc_util.msc_log('End MSC_ATP_CUSTOM.Custom_Pre_Allocation.');
9273: EXCEPTION
9274: WHEN OTHERS THEN
9275: msc_util.msc_log('Error in custom procedure call');
9276: msc_util.msc_log('Error Code: '|| sqlerrm);
9277: END;
9278: --project atp
9279:
9280: msc_util.msc_log('begin Loading pre-allocation demand/supply data for plan: ' || p_plan_id);

Line 9280: msc_util.msc_log('begin Loading pre-allocation demand/supply data for plan: ' || p_plan_id);

9276: msc_util.msc_log('Error Code: '|| sqlerrm);
9277: END;
9278: --project atp
9279:
9280: msc_util.msc_log('begin Loading pre-allocation demand/supply data for plan: ' || p_plan_id);
9281: RETCODE := G_SUCCESS;
9282:
9283: l_share_partition := fnd_profile.value('MSC_SHARE_PARTITIONS');
9284:

Line 9285: msc_util.msc_log('l_share_partition := ' || l_share_partition);

9281: RETCODE := G_SUCCESS;
9282:
9283: l_share_partition := fnd_profile.value('MSC_SHARE_PARTITIONS');
9284:
9285: msc_util.msc_log('l_share_partition := ' || l_share_partition);
9286:
9287: SELECT NVL(summary_flag,1), compile_designator
9288: INTO l_summary_flag, l_plan_name
9289: FROM msc_plans

Line 9293: msc_util.msc_log('Another session is running post-plan allocation program for this plan');

9289: FROM msc_plans
9290: WHERE plan_id = p_plan_id;
9291:
9292: IF NVL(l_summary_flag,1) = 2 THEN
9293: msc_util.msc_log('Another session is running post-plan allocation program for this plan');
9294: RETCODE := G_ERROR;
9295: RETURN;
9296: END IF;
9297:

Line 9321: msc_util.msc_log('l_partition_name := ' || l_partition_name);

9317: l_plan_id := p_plan_id;
9318: END IF;
9319:
9320: l_partition_name := atp_summ_tab(i)|| '_' || l_plan_id;
9321: msc_util.msc_log('l_partition_name := ' || l_partition_name);
9322:
9323: BEGIN
9324: SELECT count(*)
9325: INTO l_count

Line 9332: msc_util.msc_log('Inside Exception');

9328: AND partition_name = l_partition_name
9329: AND table_owner = l_msc_schema;
9330: EXCEPTION
9331: WHEN OTHERS THEN
9332: msc_util.msc_log('Inside Exception');
9333: l_count := 0;
9334: END;
9335:
9336: IF (l_count = 0) THEN

Line 9340: msc_util.msc_log(FND_MESSAGE.GET);

9336: IF (l_count = 0) THEN
9337: FND_MESSAGE.SET_NAME('MSC', 'MSC_ATP_PLAN_PARTITION_MISSING');
9338: FND_MESSAGE.SET_TOKEN('PLAN_NAME', l_plan_name);
9339: FND_MESSAGE.SET_TOKEN('TABLE_NAME', 'MSC_' || atp_summ_tab(i));
9340: msc_util.msc_log(FND_MESSAGE.GET);
9341: RETCODE := G_ERROR;
9342: RETURN;
9343: END IF;
9344: END LOOP;

Line 9358: msc_util.msc_log('l_share_partition := ' || l_share_partition);

9354: RETCODE := G_ERROR;
9355: RETURN;
9356: END;
9357:
9358: msc_util.msc_log('l_share_partition := ' || l_share_partition);
9359:
9360: BEGIN
9361: SELECT NVL(pre_alloc_hash_size, -1),
9362: NVL(pre_alloc_sort_size, -1),

Line 9371: msc_util.msc_log('Error getting performance param: ' || sqlcode || ': ' || sqlerrm);

9367: FROM msc_atp_parameters
9368: WHERE rownum = 1;
9369: EXCEPTION
9370: WHEN others THEN
9371: msc_util.msc_log('Error getting performance param: ' || sqlcode || ': ' || sqlerrm);
9372: l_hash_size := -1;
9373: l_sort_size := -1;
9374: l_parallel_degree := 1;
9375: END;

Line 9377: msc_util.msc_log('Hash: ' || l_hash_size || ' Sort: ' || l_sort_size || ' Parallel: ' || l_parallel_degree);

9373: l_sort_size := -1;
9374: l_parallel_degree := 1;
9375: END;
9376:
9377: msc_util.msc_log('Hash: ' || l_hash_size || ' Sort: ' || l_sort_size || ' Parallel: ' || l_parallel_degree);
9378:
9379: IF NVL(l_hash_size, -1) <> -1 THEN
9380: l_sql_stmt_1 := 'alter session set hash_area_size = ' || to_char(l_hash_size);
9381: msc_util.msc_log('l_sql_stmt : ' || l_sql_stmt_1);

Line 9381: msc_util.msc_log('l_sql_stmt : ' || l_sql_stmt_1);

9377: msc_util.msc_log('Hash: ' || l_hash_size || ' Sort: ' || l_sort_size || ' Parallel: ' || l_parallel_degree);
9378:
9379: IF NVL(l_hash_size, -1) <> -1 THEN
9380: l_sql_stmt_1 := 'alter session set hash_area_size = ' || to_char(l_hash_size);
9381: msc_util.msc_log('l_sql_stmt : ' || l_sql_stmt_1);
9382: execute immediate l_sql_stmt_1;
9383: END IF;
9384:
9385: IF NVL(l_sort_size, -1) <> -1 THEN

Line 9387: msc_util.msc_log('l_sql_stmt : ' || l_sql_stmt_1);

9383: END IF;
9384:
9385: IF NVL(l_sort_size, -1) <> -1 THEN
9386: l_sql_stmt_1 := 'alter session set sort_area_size = ' || to_char(l_sort_size);
9387: msc_util.msc_log('l_sql_stmt : ' || l_sql_stmt_1);
9388: execute immediate l_sql_stmt_1;
9389: END IF;
9390:
9391: /* forecast at PF changes begin

Line 9396: msc_util.msc_log('temp table : ' || l_alloc_temp_table);

9392: Changes to populate demand class allocation information in a temp table*/
9393: IF p_demand_priority = 'Y' THEN
9394: l_alloc_temp_table := 'MSC_ALLOC_TEMP_' || to_char(p_plan_id);
9395:
9396: msc_util.msc_log('temp table : ' || l_alloc_temp_table);
9397:
9398: /* Create temp table in tablespace of MSC_ALLOC_DEMANDS*/
9399: SELECT t.tablespace_name, NVL(i.def_tablespace_name, t.tablespace_name)
9400: INTO l_tbspace, l_ind_tbspace

Line 9410: msc_util.msc_log('tb space : ' || l_tbspace);

9406: AND i.owner (+) = t.table_owner
9407: AND i.table_name (+) = t.table_name
9408: AND rownum = 1;
9409:
9410: msc_util.msc_log('tb space : ' || l_tbspace);
9411: msc_util.msc_log('ind tbspace : ' || l_ind_tbspace);
9412:
9413: l_insert_stmt := 'CREATE TABLE ' || l_alloc_temp_table || '(
9414: PEGGING_ID NUMBER,

Line 9411: msc_util.msc_log('ind tbspace : ' || l_ind_tbspace);

9407: AND i.table_name (+) = t.table_name
9408: AND rownum = 1;
9409:
9410: msc_util.msc_log('tb space : ' || l_tbspace);
9411: msc_util.msc_log('ind tbspace : ' || l_ind_tbspace);
9412:
9413: l_insert_stmt := 'CREATE TABLE ' || l_alloc_temp_table || '(
9414: PEGGING_ID NUMBER,
9415: DEMAND_CLASS VARCHAR2(30),

Line 9420: msc_util.msc_log('before creating table : ' || l_alloc_temp_table);

9416: ALLOCATION_PERCENT NUMBER)
9417: TABLESPACE ' || l_tbspace || '
9418: PCTFREE 0 STORAGE(INITIAL 40K NEXT 5M PCTINCREASE 0)';
9419:
9420: msc_util.msc_log('before creating table : ' || l_alloc_temp_table);
9421:
9422: BEGIN
9423: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9424: APPLICATION_SHORT_NAME => 'MSC',

Line 9428: msc_util.msc_log('after creating table : ' || l_alloc_temp_table);

9424: APPLICATION_SHORT_NAME => 'MSC',
9425: STATEMENT_TYPE => ad_ddl.create_table,
9426: STATEMENT => l_insert_stmt,
9427: OBJECT_NAME => l_alloc_temp_table);
9428: msc_util.msc_log('after creating table : ' || l_alloc_temp_table);
9429:
9430: EXCEPTION
9431: WHEN others THEN
9432: msc_util.msc_log(sqlcode || ': ' || sqlerrm);

Line 9432: msc_util.msc_log(sqlcode || ': ' || sqlerrm);

9428: msc_util.msc_log('after creating table : ' || l_alloc_temp_table);
9429:
9430: EXCEPTION
9431: WHEN others THEN
9432: msc_util.msc_log(sqlcode || ': ' || sqlerrm);
9433: msc_util.msc_log('Exception of create table : ' || l_alloc_temp_table);
9434:
9435: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9436: APPLICATION_SHORT_NAME => 'MSC',

Line 9433: msc_util.msc_log('Exception of create table : ' || l_alloc_temp_table);

9429:
9430: EXCEPTION
9431: WHEN others THEN
9432: msc_util.msc_log(sqlcode || ': ' || sqlerrm);
9433: msc_util.msc_log('Exception of create table : ' || l_alloc_temp_table);
9434:
9435: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9436: APPLICATION_SHORT_NAME => 'MSC',
9437: STATEMENT_TYPE => ad_ddl.drop_table,

Line 9441: msc_util.msc_log('After Drop table : ' ||l_alloc_temp_table);

9437: STATEMENT_TYPE => ad_ddl.drop_table,
9438: STATEMENT => 'DROP TABLE ' || l_alloc_temp_table,
9439: OBJECT_NAME => l_alloc_temp_table);
9440:
9441: msc_util.msc_log('After Drop table : ' ||l_alloc_temp_table);
9442: msc_util.msc_log('Before exception create table : ' ||l_alloc_temp_table);
9443:
9444: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9445: APPLICATION_SHORT_NAME => 'MSC',

Line 9442: msc_util.msc_log('Before exception create table : ' ||l_alloc_temp_table);

9438: STATEMENT => 'DROP TABLE ' || l_alloc_temp_table,
9439: OBJECT_NAME => l_alloc_temp_table);
9440:
9441: msc_util.msc_log('After Drop table : ' ||l_alloc_temp_table);
9442: msc_util.msc_log('Before exception create table : ' ||l_alloc_temp_table);
9443:
9444: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9445: APPLICATION_SHORT_NAME => 'MSC',
9446: STATEMENT_TYPE => ad_ddl.create_table,

Line 9450: msc_util.msc_log('After exception create table : ' ||l_alloc_temp_table);

9446: STATEMENT_TYPE => ad_ddl.create_table,
9447: STATEMENT => l_insert_stmt,
9448: OBJECT_NAME => l_alloc_temp_table);
9449:
9450: msc_util.msc_log('After exception create table : ' ||l_alloc_temp_table);
9451: END;
9452:
9453: Calculate_Alloc_Percentages(p_plan_id, l_return_status);
9454:

Line 9457: msc_util.msc_log('Pf_Post_Plan_Proc: ' || 'Error occured in procedure Calculate_Alloc_Percentages');

9453: Calculate_Alloc_Percentages(p_plan_id, l_return_status);
9454:
9455: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
9456: IF PG_DEBUG in ('Y', 'C') THEN
9457: msc_util.msc_log('Pf_Post_Plan_Proc: ' || 'Error occured in procedure Calculate_Alloc_Percentages');
9458: END IF;
9459: RAISE FND_API.G_EXC_ERROR;
9460: END IF;
9461:

Line 9462: msc_util.msc_log('Before generating the SQL');

9458: END IF;
9459: RAISE FND_API.G_EXC_ERROR;
9460: END IF;
9461:
9462: msc_util.msc_log('Before generating the SQL');
9463:
9464: l_insert_stmt := 'insert into '|| l_alloc_temp_table ||'(
9465: pegging_id,
9466: demand_class,

Line 9494: msc_util.msc_log(l_insert_stmt);

9490: and peg1.plan_id = d.plan_id
9491: and d.disposition_id = mat.transaction_id (+)
9492: )';
9493:
9494: msc_util.msc_log(l_insert_stmt);
9495: msc_util.msc_log('After generating the SQL');
9496:
9497: -- Obtain cursor handler for sql_stmt
9498: cur_handler := DBMS_SQL.OPEN_CURSOR;

Line 9495: msc_util.msc_log('After generating the SQL');

9491: and d.disposition_id = mat.transaction_id (+)
9492: )';
9493:
9494: msc_util.msc_log(l_insert_stmt);
9495: msc_util.msc_log('After generating the SQL');
9496:
9497: -- Obtain cursor handler for sql_stmt
9498: cur_handler := DBMS_SQL.OPEN_CURSOR;
9499:

Line 9502: msc_util.msc_log('After parsing the SQL');

9498: cur_handler := DBMS_SQL.OPEN_CURSOR;
9499:
9500: DBMS_SQL.PARSE(cur_handler, l_insert_stmt, DBMS_SQL.NATIVE);
9501:
9502: msc_util.msc_log('After parsing the SQL');
9503:
9504: DBMS_SQL.BIND_VARIABLE(cur_handler, ':l_excess_dc', l_excess_dc);
9505: DBMS_SQL.BIND_VARIABLE(cur_handler, ':p_plan_id', p_plan_id);
9506:

Line 9507: msc_util.msc_log('after binding the variables');

9503:
9504: DBMS_SQL.BIND_VARIABLE(cur_handler, ':l_excess_dc', l_excess_dc);
9505: DBMS_SQL.BIND_VARIABLE(cur_handler, ':p_plan_id', p_plan_id);
9506:
9507: msc_util.msc_log('after binding the variables');
9508:
9509: -- Execute the cursor
9510: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9511:

Line 9512: msc_util.msc_log('After executing the cursor');

9508:
9509: -- Execute the cursor
9510: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9511:
9512: msc_util.msc_log('After executing the cursor');
9513:
9514: commit;
9515:
9516: msc_util.msc_log('before creating indexes on temp table');

Line 9516: msc_util.msc_log('before creating indexes on temp table');

9512: msc_util.msc_log('After executing the cursor');
9513:
9514: commit;
9515:
9516: msc_util.msc_log('before creating indexes on temp table');
9517:
9518: l_sql_stmt_1 := 'CREATE INDEX ' || l_alloc_temp_table || '_N1 ON ' || l_alloc_temp_table || '
9519: (pegging_id)
9520: STORAGE(INITIAL 40K NEXT 2M PCTINCREASE 0) tablespace ' || l_ind_tbspace;

Line 9522: msc_util.msc_log('Before index : ' || l_alloc_temp_table || '.' || l_alloc_temp_table || '_N1');

9518: l_sql_stmt_1 := 'CREATE INDEX ' || l_alloc_temp_table || '_N1 ON ' || l_alloc_temp_table || '
9519: (pegging_id)
9520: STORAGE(INITIAL 40K NEXT 2M PCTINCREASE 0) tablespace ' || l_ind_tbspace;
9521:
9522: msc_util.msc_log('Before index : ' || l_alloc_temp_table || '.' || l_alloc_temp_table || '_N1');
9523:
9524: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9525: APPLICATION_SHORT_NAME => 'MSC',
9526: STATEMENT_TYPE => ad_ddl.create_index,

Line 9530: msc_util.msc_log('After index : ' || l_alloc_temp_table || '.' || l_alloc_temp_table || '_N1');

9526: STATEMENT_TYPE => ad_ddl.create_index,
9527: STATEMENT => l_sql_stmt_1,
9528: OBJECT_NAME => l_alloc_temp_table);
9529:
9530: msc_util.msc_log('After index : ' || l_alloc_temp_table || '.' || l_alloc_temp_table || '_N1');
9531: msc_util.msc_log('Done creating indexes on temp table');
9532: msc_util.msc_log('Gather Table Stats');
9533:
9534: -- Use p_plan_id instead of l_plan_id

Line 9531: msc_util.msc_log('Done creating indexes on temp table');

9527: STATEMENT => l_sql_stmt_1,
9528: OBJECT_NAME => l_alloc_temp_table);
9529:
9530: msc_util.msc_log('After index : ' || l_alloc_temp_table || '.' || l_alloc_temp_table || '_N1');
9531: msc_util.msc_log('Done creating indexes on temp table');
9532: msc_util.msc_log('Gather Table Stats');
9533:
9534: -- Use p_plan_id instead of l_plan_id
9535: --fnd_stats.gather_table_stats('MSC', 'MSC_ALLOC_TEMP_' || to_char(l_plan_id), granularity => 'ALL');

Line 9532: msc_util.msc_log('Gather Table Stats');

9528: OBJECT_NAME => l_alloc_temp_table);
9529:
9530: msc_util.msc_log('After index : ' || l_alloc_temp_table || '.' || l_alloc_temp_table || '_N1');
9531: msc_util.msc_log('Done creating indexes on temp table');
9532: msc_util.msc_log('Gather Table Stats');
9533:
9534: -- Use p_plan_id instead of l_plan_id
9535: --fnd_stats.gather_table_stats('MSC', 'MSC_ALLOC_TEMP_' || to_char(l_plan_id), granularity => 'ALL');
9536: fnd_stats.gather_table_stats(l_msc_schema, l_alloc_temp_table, granularity => 'ALL');

Line 9542: msc_util.msc_log('Inside shared partition');

9538: /* forecast at PF changes end*/
9539:
9540: IF l_share_partition = 'Y' THEN
9541:
9542: msc_util.msc_log('Inside shared partition');
9543:
9544: -- first delete the existing data from tables
9545: msc_util.msc_log('before deleteing data from the table');
9546:

Line 9545: msc_util.msc_log('before deleteing data from the table');

9541:
9542: msc_util.msc_log('Inside shared partition');
9543:
9544: -- first delete the existing data from tables
9545: msc_util.msc_log('before deleteing data from the table');
9546:
9547: DELETE MSC_ALLOC_DEMANDS where plan_id = p_plan_id;
9548: msc_util.msc_log('After deleting data from MSC_ALLOC_DEMANDS table');
9549:

Line 9548: msc_util.msc_log('After deleting data from MSC_ALLOC_DEMANDS table');

9544: -- first delete the existing data from tables
9545: msc_util.msc_log('before deleteing data from the table');
9546:
9547: DELETE MSC_ALLOC_DEMANDS where plan_id = p_plan_id;
9548: msc_util.msc_log('After deleting data from MSC_ALLOC_DEMANDS table');
9549:
9550: DELETE MSC_ALLOC_SUPPLIES where plan_id = p_plan_id;
9551: msc_util.msc_log('After deleting data from MSC_ALLOC_SUPPLIES table');
9552:

Line 9551: msc_util.msc_log('After deleting data from MSC_ALLOC_SUPPLIES table');

9547: DELETE MSC_ALLOC_DEMANDS where plan_id = p_plan_id;
9548: msc_util.msc_log('After deleting data from MSC_ALLOC_DEMANDS table');
9549:
9550: DELETE MSC_ALLOC_SUPPLIES where plan_id = p_plan_id;
9551: msc_util.msc_log('After deleting data from MSC_ALLOC_SUPPLIES table');
9552:
9553: /*--------------------------------------------------------------------------
9554: | <<<<<<<<<<<<<<<<<<<<<<< Begin Demands SQL1 >>>>>>>>>>>>>>>>>>>>>>>>>>>
9555: +-------------------------------------------------------------------------*/

Line 9556: msc_util.msc_log('Before generating Demands SQL1');

9552:
9553: /*--------------------------------------------------------------------------
9554: | <<<<<<<<<<<<<<<<<<<<<<< Begin Demands SQL1 >>>>>>>>>>>>>>>>>>>>>>>>>>>
9555: +-------------------------------------------------------------------------*/
9556: msc_util.msc_log('Before generating Demands SQL1');
9557:
9558: /* forecast at PF changes begin*/
9559: Prepare_Demands_Stmt(l_share_partition, p_demand_priority, l_excess_supply_by_dc,
9560: NULL, l_alloc_temp_table, l_parallel_degree, l_sql_stmt_1, l_return_status);

Line 9563: msc_util.msc_log('Pf_Post_Plan_Proc: ' || 'Error occured in procedure Prepare_Demands_Stmt');

9559: Prepare_Demands_Stmt(l_share_partition, p_demand_priority, l_excess_supply_by_dc,
9560: NULL, l_alloc_temp_table, l_parallel_degree, l_sql_stmt_1, l_return_status);
9561: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
9562: IF PG_DEBUG in ('Y', 'C') THEN
9563: msc_util.msc_log('Pf_Post_Plan_Proc: ' || 'Error occured in procedure Prepare_Demands_Stmt');
9564: END IF;
9565: RAISE FND_API.G_EXC_ERROR;
9566: END IF;
9567:

Line 9568: msc_util.msc_log('After generating Demands SQL1');

9564: END IF;
9565: RAISE FND_API.G_EXC_ERROR;
9566: END IF;
9567:
9568: msc_util.msc_log('After generating Demands SQL1');
9569: msc_util.msc_log(l_sql_stmt_1);
9570:
9571: -- Obtain cursor handler for sql_stmt
9572: cur_handler := DBMS_SQL.OPEN_CURSOR;

Line 9569: msc_util.msc_log(l_sql_stmt_1);

9565: RAISE FND_API.G_EXC_ERROR;
9566: END IF;
9567:
9568: msc_util.msc_log('After generating Demands SQL1');
9569: msc_util.msc_log(l_sql_stmt_1);
9570:
9571: -- Obtain cursor handler for sql_stmt
9572: cur_handler := DBMS_SQL.OPEN_CURSOR;
9573:

Line 9575: msc_util.msc_log('After parsing Demands SQL1');

9571: -- Obtain cursor handler for sql_stmt
9572: cur_handler := DBMS_SQL.OPEN_CURSOR;
9573:
9574: DBMS_SQL.PARSE(cur_handler, l_sql_stmt_1, DBMS_SQL.NATIVE);
9575: msc_util.msc_log('After parsing Demands SQL1');
9576:
9577: DBMS_SQL.BIND_VARIABLE(cur_handler, ':l_user_id', l_user_id);
9578: DBMS_SQL.BIND_VARIABLE(cur_handler, ':l_sysdate', l_sysdate);
9579: DBMS_SQL.BIND_VARIABLE(cur_handler, ':p_plan_id', p_plan_id);

Line 9586: msc_util.msc_log('after binding the variables');

9582: DBMS_SQL.BIND_VARIABLE(cur_handler, ':l_excess_dc', l_excess_dc);
9583: DBMS_SQL.BIND_VARIABLE(cur_handler, ':p_excess_supply_by_dc', l_excess_supply_by_dc);
9584: DBMS_SQL.BIND_VARIABLE(cur_handler, ':def_num', '-1');
9585: END IF;
9586: msc_util.msc_log('after binding the variables');
9587:
9588: -- Execute the cursor
9589: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9590: msc_util.msc_log('After executing the cursor');

Line 9590: msc_util.msc_log('After executing the cursor');

9586: msc_util.msc_log('after binding the variables');
9587:
9588: -- Execute the cursor
9589: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9590: msc_util.msc_log('After executing the cursor');
9591:
9592: msc_util.msc_log('rows processed: ' || rows_processed);
9593: msc_util.msc_log('after inserting item data into MSC_ALLOC_DEMANDS tables');
9594:

Line 9592: msc_util.msc_log('rows processed: ' || rows_processed);

9588: -- Execute the cursor
9589: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9590: msc_util.msc_log('After executing the cursor');
9591:
9592: msc_util.msc_log('rows processed: ' || rows_processed);
9593: msc_util.msc_log('after inserting item data into MSC_ALLOC_DEMANDS tables');
9594:
9595: /*--------------------------------------------------------------------------
9596: | <<<<<<<<<<<<<<<<<<<<<<< Begin Supplies SQL1 >>>>>>>>>>>>>>>>>>>>>>>>>>>

Line 9593: msc_util.msc_log('after inserting item data into MSC_ALLOC_DEMANDS tables');

9589: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9590: msc_util.msc_log('After executing the cursor');
9591:
9592: msc_util.msc_log('rows processed: ' || rows_processed);
9593: msc_util.msc_log('after inserting item data into MSC_ALLOC_DEMANDS tables');
9594:
9595: /*--------------------------------------------------------------------------
9596: | <<<<<<<<<<<<<<<<<<<<<<< Begin Supplies SQL1 >>>>>>>>>>>>>>>>>>>>>>>>>>>
9597: +-------------------------------------------------------------------------*/

Line 9598: msc_util.msc_log('Before generating Supplies SQL1');

9594:
9595: /*--------------------------------------------------------------------------
9596: | <<<<<<<<<<<<<<<<<<<<<<< Begin Supplies SQL1 >>>>>>>>>>>>>>>>>>>>>>>>>>>
9597: +-------------------------------------------------------------------------*/
9598: msc_util.msc_log('Before generating Supplies SQL1');
9599:
9600: Prepare_Supplies_Stmt(l_share_partition, p_demand_priority,
9601: l_excess_supply_by_dc, NULL, l_alloc_temp_table, l_parallel_degree, l_sql_stmt_1, l_return_status);
9602:

Line 9605: msc_util.msc_log('Pf_Post_Plan_Proc: ' || 'Error occured in procedure Prepare_Supplies_Stmt');

9601: l_excess_supply_by_dc, NULL, l_alloc_temp_table, l_parallel_degree, l_sql_stmt_1, l_return_status);
9602:
9603: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
9604: IF PG_DEBUG in ('Y', 'C') THEN
9605: msc_util.msc_log('Pf_Post_Plan_Proc: ' || 'Error occured in procedure Prepare_Supplies_Stmt');
9606: END IF;
9607: RAISE FND_API.G_EXC_ERROR;
9608: END IF;
9609:

Line 9610: msc_util.msc_log(l_sql_stmt_1);

9606: END IF;
9607: RAISE FND_API.G_EXC_ERROR;
9608: END IF;
9609:
9610: msc_util.msc_log(l_sql_stmt_1);
9611: msc_util.msc_log('After Generating Supplies SQL1');
9612:
9613: -- Parse cursor handler for sql_stmt: Don't open as its already opened
9614:

Line 9611: msc_util.msc_log('After Generating Supplies SQL1');

9607: RAISE FND_API.G_EXC_ERROR;
9608: END IF;
9609:
9610: msc_util.msc_log(l_sql_stmt_1);
9611: msc_util.msc_log('After Generating Supplies SQL1');
9612:
9613: -- Parse cursor handler for sql_stmt: Don't open as its already opened
9614:
9615: DBMS_SQL.PARSE(cur_handler, l_sql_stmt_1, DBMS_SQL.NATIVE);

Line 9616: msc_util.msc_log('After parsing Supplies SQL1');

9612:
9613: -- Parse cursor handler for sql_stmt: Don't open as its already opened
9614:
9615: DBMS_SQL.PARSE(cur_handler, l_sql_stmt_1, DBMS_SQL.NATIVE);
9616: msc_util.msc_log('After parsing Supplies SQL1');
9617:
9618: DBMS_SQL.BIND_VARIABLE(cur_handler, ':l_user_id', l_user_id);
9619: DBMS_SQL.BIND_VARIABLE(cur_handler, ':l_sysdate', l_sysdate);
9620: DBMS_SQL.BIND_VARIABLE(cur_handler, ':p_plan_id', p_plan_id);

Line 9629: msc_util.msc_log('after binding the variables');

9625: DBMS_SQL.BIND_VARIABLE(cur_handler, ':def_num', '-1');
9626: END IF;
9627: /* forecast at PF changes end*/
9628:
9629: msc_util.msc_log('after binding the variables');
9630:
9631: -- Execute the cursor
9632: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9633: msc_util.msc_log('After executing first supplies cursor');

Line 9633: msc_util.msc_log('After executing first supplies cursor');

9629: msc_util.msc_log('after binding the variables');
9630:
9631: -- Execute the cursor
9632: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9633: msc_util.msc_log('After executing first supplies cursor');
9634:
9635: msc_util.msc_log('rows processed: ' || rows_processed);
9636: msc_util.msc_log('after inserting item data into MSC_ALLOC_SUPPLIES tables');
9637:

Line 9635: msc_util.msc_log('rows processed: ' || rows_processed);

9631: -- Execute the cursor
9632: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9633: msc_util.msc_log('After executing first supplies cursor');
9634:
9635: msc_util.msc_log('rows processed: ' || rows_processed);
9636: msc_util.msc_log('after inserting item data into MSC_ALLOC_SUPPLIES tables');
9637:
9638: msc_util.msc_log('Analyze Plan partition for MSC_ALLOC_DEMANDS');
9639: fnd_stats.gather_table_stats(ownname=>l_msc_schema,tabname=>'MSC_ALLOC_DEMANDS',

Line 9636: msc_util.msc_log('after inserting item data into MSC_ALLOC_SUPPLIES tables');

9632: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9633: msc_util.msc_log('After executing first supplies cursor');
9634:
9635: msc_util.msc_log('rows processed: ' || rows_processed);
9636: msc_util.msc_log('after inserting item data into MSC_ALLOC_SUPPLIES tables');
9637:
9638: msc_util.msc_log('Analyze Plan partition for MSC_ALLOC_DEMANDS');
9639: fnd_stats.gather_table_stats(ownname=>l_msc_schema,tabname=>'MSC_ALLOC_DEMANDS',
9640: partname=>'ALLOC_DEMANDS_999999',

Line 9638: msc_util.msc_log('Analyze Plan partition for MSC_ALLOC_DEMANDS');

9634:
9635: msc_util.msc_log('rows processed: ' || rows_processed);
9636: msc_util.msc_log('after inserting item data into MSC_ALLOC_SUPPLIES tables');
9637:
9638: msc_util.msc_log('Analyze Plan partition for MSC_ALLOC_DEMANDS');
9639: fnd_stats.gather_table_stats(ownname=>l_msc_schema,tabname=>'MSC_ALLOC_DEMANDS',
9640: partname=>'ALLOC_DEMANDS_999999',
9641: granularity=>'PARTITION',
9642: percent =>10);

Line 9644: msc_util.msc_log('Analyze Plan partition for MSC_ALLOC_SUPPLIES');

9640: partname=>'ALLOC_DEMANDS_999999',
9641: granularity=>'PARTITION',
9642: percent =>10);
9643:
9644: msc_util.msc_log('Analyze Plan partition for MSC_ALLOC_SUPPLIES');
9645: fnd_stats.gather_table_stats(ownname=>l_msc_schema,tabname=>'MSC_ALLOC_SUPPLIES',
9646: partname=>'ALLOC_SUPPLIES_999999',
9647: granularity=>'PARTITION',
9648: percent =>10);

Line 9652: msc_util.msc_log('not a shared plan partition, insert data into temp tables');

9648: percent =>10);
9649:
9650: ELSE
9651:
9652: msc_util.msc_log('not a shared plan partition, insert data into temp tables');
9653:
9654: l_temp_table := 'MSC_TEMP_ALLOC_DEM_' || to_char(l_plan_id);
9655:
9656: msc_util.msc_log('temp table : ' || l_temp_table);

Line 9656: msc_util.msc_log('temp table : ' || l_temp_table);

9652: msc_util.msc_log('not a shared plan partition, insert data into temp tables');
9653:
9654: l_temp_table := 'MSC_TEMP_ALLOC_DEM_' || to_char(l_plan_id);
9655:
9656: msc_util.msc_log('temp table : ' || l_temp_table);
9657:
9658: IF p_demand_priority <> 'Y' THEN
9659: SELECT t.tablespace_name, NVL(i.def_tablespace_name, t.tablespace_name)
9660: INTO l_tbspace, l_ind_tbspace

Line 9670: msc_util.msc_log('tb space : ' || l_tbspace);

9666: AND i.owner (+) = t.table_owner
9667: AND i.table_name (+) = t.table_name
9668: AND rownum = 1;
9669:
9670: msc_util.msc_log('tb space : ' || l_tbspace);
9671: msc_util.msc_log('ind tbspace : ' || l_ind_tbspace);
9672: END IF;
9673:
9674: --bug 6113544

Line 9671: msc_util.msc_log('ind tbspace : ' || l_ind_tbspace);

9667: AND i.table_name (+) = t.table_name
9668: AND rownum = 1;
9669:
9670: msc_util.msc_log('tb space : ' || l_tbspace);
9671: msc_util.msc_log('ind tbspace : ' || l_ind_tbspace);
9672: END IF;
9673:
9674: --bug 6113544
9675: l_insert_stmt := 'CREATE TABLE ' || l_temp_table

Line 9716: msc_util.msc_log('before creating table : ' || l_temp_table);

9712: TABLESPACE ' || l_tbspace || '
9713: PCTFREE 0 STORAGE(INITIAL 40K NEXT 5M PCTINCREASE 0)';
9714: */
9715:
9716: msc_util.msc_log('before creating table : ' || l_temp_table);
9717: BEGIN
9718: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9719: APPLICATION_SHORT_NAME => 'MSC',
9720: STATEMENT_TYPE => ad_ddl.create_table,

Line 9723: msc_util.msc_log('after creating table : ' || l_temp_table);

9719: APPLICATION_SHORT_NAME => 'MSC',
9720: STATEMENT_TYPE => ad_ddl.create_table,
9721: STATEMENT => l_insert_stmt,
9722: OBJECT_NAME => l_temp_table);
9723: msc_util.msc_log('after creating table : ' || l_temp_table);
9724:
9725: EXCEPTION
9726: WHEN others THEN
9727: msc_util.msc_log(sqlcode || ': ' || sqlerrm);

Line 9727: msc_util.msc_log(sqlcode || ': ' || sqlerrm);

9723: msc_util.msc_log('after creating table : ' || l_temp_table);
9724:
9725: EXCEPTION
9726: WHEN others THEN
9727: msc_util.msc_log(sqlcode || ': ' || sqlerrm);
9728: msc_util.msc_log('Exception of create table : ' || l_temp_table);
9729:
9730: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9731: APPLICATION_SHORT_NAME => 'MSC',

Line 9728: msc_util.msc_log('Exception of create table : ' || l_temp_table);

9724:
9725: EXCEPTION
9726: WHEN others THEN
9727: msc_util.msc_log(sqlcode || ': ' || sqlerrm);
9728: msc_util.msc_log('Exception of create table : ' || l_temp_table);
9729:
9730: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9731: APPLICATION_SHORT_NAME => 'MSC',
9732: STATEMENT_TYPE => ad_ddl.drop_table,

Line 9736: msc_util.msc_log('After Drop table : ' ||l_temp_table);

9732: STATEMENT_TYPE => ad_ddl.drop_table,
9733: STATEMENT => 'DROP TABLE ' || l_temp_table,
9734: OBJECT_NAME => l_temp_table);
9735:
9736: msc_util.msc_log('After Drop table : ' ||l_temp_table);
9737: msc_util.msc_log('Before exception create table : ' ||l_temp_table);
9738:
9739: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9740: APPLICATION_SHORT_NAME => 'MSC',

Line 9737: msc_util.msc_log('Before exception create table : ' ||l_temp_table);

9733: STATEMENT => 'DROP TABLE ' || l_temp_table,
9734: OBJECT_NAME => l_temp_table);
9735:
9736: msc_util.msc_log('After Drop table : ' ||l_temp_table);
9737: msc_util.msc_log('Before exception create table : ' ||l_temp_table);
9738:
9739: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9740: APPLICATION_SHORT_NAME => 'MSC',
9741: STATEMENT_TYPE => ad_ddl.create_table,

Line 9744: msc_util.msc_log('After exception create table : ' ||l_temp_table);

9740: APPLICATION_SHORT_NAME => 'MSC',
9741: STATEMENT_TYPE => ad_ddl.create_table,
9742: STATEMENT => l_insert_stmt,
9743: OBJECT_NAME => l_temp_table);
9744: msc_util.msc_log('After exception create table : ' ||l_temp_table);
9745: END;
9746:
9747: /*--------------------------------------------------------------------------
9748: | <<<<<<<<<<<<<<<<<<<<<<< Begin Demands SQL1 >>>>>>>>>>>>>>>>>>>>>>>>>>>

Line 9750: msc_util.msc_log('Before generating Demands SQL1');

9746:
9747: /*--------------------------------------------------------------------------
9748: | <<<<<<<<<<<<<<<<<<<<<<< Begin Demands SQL1 >>>>>>>>>>>>>>>>>>>>>>>>>>>
9749: +-------------------------------------------------------------------------*/
9750: msc_util.msc_log('Before generating Demands SQL1');
9751:
9752: /* forecast at PF changes begin*/
9753: Prepare_Demands_Stmt(l_share_partition, p_demand_priority, l_excess_supply_by_dc,
9754: l_temp_table, l_alloc_temp_table, l_parallel_degree, l_sql_stmt_1, l_return_status);

Line 9758: msc_util.msc_log('Pf_Post_Plan_Proc: ' || 'Error occured in procedure Prepare_Demands_Stmt');

9754: l_temp_table, l_alloc_temp_table, l_parallel_degree, l_sql_stmt_1, l_return_status);
9755:
9756: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
9757: IF PG_DEBUG in ('Y', 'C') THEN
9758: msc_util.msc_log('Pf_Post_Plan_Proc: ' || 'Error occured in procedure Prepare_Demands_Stmt');
9759: END IF;
9760: RAISE FND_API.G_EXC_ERROR;
9761: END IF;
9762:

Line 9763: msc_util.msc_log(l_sql_stmt_1);

9759: END IF;
9760: RAISE FND_API.G_EXC_ERROR;
9761: END IF;
9762:
9763: msc_util.msc_log(l_sql_stmt_1);
9764: msc_util.msc_log('After generating Demands SQL1');
9765:
9766: -- Obtain cursor handler for sql_stmt
9767: cur_handler := DBMS_SQL.OPEN_CURSOR;

Line 9764: msc_util.msc_log('After generating Demands SQL1');

9760: RAISE FND_API.G_EXC_ERROR;
9761: END IF;
9762:
9763: msc_util.msc_log(l_sql_stmt_1);
9764: msc_util.msc_log('After generating Demands SQL1');
9765:
9766: -- Obtain cursor handler for sql_stmt
9767: cur_handler := DBMS_SQL.OPEN_CURSOR;
9768:

Line 9770: msc_util.msc_log('After parsing Demands SQL1');

9766: -- Obtain cursor handler for sql_stmt
9767: cur_handler := DBMS_SQL.OPEN_CURSOR;
9768:
9769: DBMS_SQL.PARSE(cur_handler, l_sql_stmt_1, DBMS_SQL.NATIVE);
9770: msc_util.msc_log('After parsing Demands SQL1');
9771:
9772: DBMS_SQL.BIND_VARIABLE(cur_handler, ':l_user_id', l_user_id);
9773: DBMS_SQL.BIND_VARIABLE(cur_handler, ':l_sysdate', l_sysdate);
9774: DBMS_SQL.BIND_VARIABLE(cur_handler, ':p_plan_id', p_plan_id);

Line 9783: msc_util.msc_log('after binding the variables');

9779: DBMS_SQL.BIND_VARIABLE(cur_handler, ':def_num', '-1');
9780: END IF;
9781: /* forecast at PF changes end*/
9782:
9783: msc_util.msc_log('after binding the variables');
9784:
9785: -- Execute the cursor
9786: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9787: msc_util.msc_log('After executing the cursor');

Line 9787: msc_util.msc_log('After executing the cursor');

9783: msc_util.msc_log('after binding the variables');
9784:
9785: -- Execute the cursor
9786: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9787: msc_util.msc_log('After executing the cursor');
9788: msc_util.msc_log('after inserting item data into MSC_TEMP_ALLOC_DEMANDS table');
9789:
9790: commit;
9791:

Line 9788: msc_util.msc_log('after inserting item data into MSC_TEMP_ALLOC_DEMANDS table');

9784:
9785: -- Execute the cursor
9786: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9787: msc_util.msc_log('After executing the cursor');
9788: msc_util.msc_log('after inserting item data into MSC_TEMP_ALLOC_DEMANDS table');
9789:
9790: commit;
9791:
9792: msc_util.msc_log('before creating indexes on temp demand table');

Line 9792: msc_util.msc_log('before creating indexes on temp demand table');

9788: msc_util.msc_log('after inserting item data into MSC_TEMP_ALLOC_DEMANDS table');
9789:
9790: commit;
9791:
9792: msc_util.msc_log('before creating indexes on temp demand table');
9793: l_sql_stmt_1 := 'CREATE INDEX ' || l_temp_table || '_N1 ON ' || l_temp_table || '
9794: --NOLOGGING
9795: (plan_id, inventory_item_id, organization_id, sr_instance_id, demand_class, demand_date)
9796: STORAGE(INITIAL 40K NEXT 2M PCTINCREASE 0) tablespace ' || l_ind_tbspace;

Line 9798: msc_util.msc_log('Before index : ' || l_temp_table || '.' || l_temp_table || '_N1');

9794: --NOLOGGING
9795: (plan_id, inventory_item_id, organization_id, sr_instance_id, demand_class, demand_date)
9796: STORAGE(INITIAL 40K NEXT 2M PCTINCREASE 0) tablespace ' || l_ind_tbspace;
9797:
9798: msc_util.msc_log('Before index : ' || l_temp_table || '.' || l_temp_table || '_N1');
9799:
9800: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9801: APPLICATION_SHORT_NAME => 'MSC',
9802: STATEMENT_TYPE => ad_ddl.create_index,

Line 9806: msc_util.msc_log('After index : ' || l_temp_table || '.' || l_temp_table || '_N1');

9802: STATEMENT_TYPE => ad_ddl.create_index,
9803: STATEMENT => l_sql_stmt_1,
9804: OBJECT_NAME => l_temp_table);
9805:
9806: msc_util.msc_log('After index : ' || l_temp_table || '.' || l_temp_table || '_N1');
9807:
9808: l_sql_stmt_1 := 'CREATE INDEX ' || l_temp_table || '_N2 ON ' || l_temp_table || '
9809: -- NOLOGGING
9810: --Bug 3629191

Line 9815: msc_util.msc_log('Before index : ' || l_temp_table || '.' || l_temp_table || '_N2');

9811: (plan_id,
9812: sales_order_line_id)
9813: STORAGE(INITIAL 40K NEXT 2M PCTINCREASE 0) tablespace ' || l_ind_tbspace;
9814:
9815: msc_util.msc_log('Before index : ' || l_temp_table || '.' || l_temp_table || '_N2');
9816:
9817: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9818: APPLICATION_SHORT_NAME => 'MSC',
9819: STATEMENT_TYPE => ad_ddl.create_index,

Line 9823: msc_util.msc_log('After index : ' || l_temp_table || '.' || l_temp_table || '_N2');

9819: STATEMENT_TYPE => ad_ddl.create_index,
9820: STATEMENT => l_sql_stmt_1,
9821: OBJECT_NAME => l_temp_table);
9822:
9823: msc_util.msc_log('After index : ' || l_temp_table || '.' || l_temp_table || '_N2');
9824:
9825: l_sql_stmt_1 := 'CREATE INDEX ' || l_temp_table || '_N3 ON ' || l_temp_table || '
9826: -- NOLOGGING
9827: --Bug 3629191

Line 9832: msc_util.msc_log('Before index : ' || l_temp_table || '.' || l_temp_table || '_N3');

9828: (plan_id,
9829: parent_demand_id)
9830: STORAGE(INITIAL 40K NEXT 2M PCTINCREASE 0) tablespace ' || l_ind_tbspace;
9831:
9832: msc_util.msc_log('Before index : ' || l_temp_table || '.' || l_temp_table || '_N3');
9833:
9834: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9835: APPLICATION_SHORT_NAME => 'MSC',
9836: STATEMENT_TYPE => ad_ddl.create_index,

Line 9840: msc_util.msc_log('After index : ' || l_temp_table || '.' || l_temp_table || '_N3');

9836: STATEMENT_TYPE => ad_ddl.create_index,
9837: STATEMENT => l_sql_stmt_1,
9838: OBJECT_NAME => l_temp_table);
9839:
9840: msc_util.msc_log('After index : ' || l_temp_table || '.' || l_temp_table || '_N3');
9841: msc_util.msc_log('Done creating indexes on temp demand table');
9842:
9843: l_temp_table := 'MSC_TEMP_ALLOC_SUP_' || to_char(l_plan_id);
9844:

Line 9841: msc_util.msc_log('Done creating indexes on temp demand table');

9837: STATEMENT => l_sql_stmt_1,
9838: OBJECT_NAME => l_temp_table);
9839:
9840: msc_util.msc_log('After index : ' || l_temp_table || '.' || l_temp_table || '_N3');
9841: msc_util.msc_log('Done creating indexes on temp demand table');
9842:
9843: l_temp_table := 'MSC_TEMP_ALLOC_SUP_' || to_char(l_plan_id);
9844:
9845: SELECT t.tablespace_name, NVL(i.def_tablespace_name, t.tablespace_name)

Line 9856: msc_util.msc_log('tb space : ' || l_tbspace);

9852: AND i.owner (+) = t.table_owner
9853: AND i.table_name (+) = t.table_name
9854: AND rownum = 1;
9855:
9856: msc_util.msc_log('tb space : ' || l_tbspace);
9857: msc_util.msc_log('ind tbspace : ' || l_ind_tbspace);
9858:
9859: --bug 6113544
9860: l_insert_stmt := 'CREATE TABLE ' || l_temp_table

Line 9857: msc_util.msc_log('ind tbspace : ' || l_ind_tbspace);

9853: AND i.table_name (+) = t.table_name
9854: AND rownum = 1;
9855:
9856: msc_util.msc_log('tb space : ' || l_tbspace);
9857: msc_util.msc_log('ind tbspace : ' || l_ind_tbspace);
9858:
9859: --bug 6113544
9860: l_insert_stmt := 'CREATE TABLE ' || l_temp_table
9861: || ' TABLESPACE ' || l_tbspace

Line 9901: msc_util.msc_log('before creating table : ' || l_temp_table);

9897: TABLESPACE ' || l_tbspace || '
9898: PCTFREE 0 STORAGE(INITIAL 40K NEXT 5M PCTINCREASE 0)';
9899: */
9900:
9901: msc_util.msc_log('before creating table : ' || l_temp_table);
9902: BEGIN
9903: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9904: APPLICATION_SHORT_NAME => 'MSC',
9905: STATEMENT_TYPE => ad_ddl.create_table,

Line 9908: msc_util.msc_log('after creating table : ' || l_temp_table);

9904: APPLICATION_SHORT_NAME => 'MSC',
9905: STATEMENT_TYPE => ad_ddl.create_table,
9906: STATEMENT => l_insert_stmt,
9907: OBJECT_NAME => l_temp_table);
9908: msc_util.msc_log('after creating table : ' || l_temp_table);
9909:
9910: EXCEPTION
9911: WHEN others THEN
9912: msc_util.msc_log(sqlcode || ': ' || sqlerrm);

Line 9912: msc_util.msc_log(sqlcode || ': ' || sqlerrm);

9908: msc_util.msc_log('after creating table : ' || l_temp_table);
9909:
9910: EXCEPTION
9911: WHEN others THEN
9912: msc_util.msc_log(sqlcode || ': ' || sqlerrm);
9913: msc_util.msc_log('Exception of create table : ' || l_temp_table);
9914:
9915: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9916: APPLICATION_SHORT_NAME => 'MSC',

Line 9913: msc_util.msc_log('Exception of create table : ' || l_temp_table);

9909:
9910: EXCEPTION
9911: WHEN others THEN
9912: msc_util.msc_log(sqlcode || ': ' || sqlerrm);
9913: msc_util.msc_log('Exception of create table : ' || l_temp_table);
9914:
9915: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9916: APPLICATION_SHORT_NAME => 'MSC',
9917: STATEMENT_TYPE => ad_ddl.drop_table,

Line 9921: msc_util.msc_log('After Drop table : ' ||l_temp_table);

9917: STATEMENT_TYPE => ad_ddl.drop_table,
9918: STATEMENT => 'DROP TABLE ' || l_temp_table,
9919: OBJECT_NAME => l_temp_table);
9920:
9921: msc_util.msc_log('After Drop table : ' ||l_temp_table);
9922: msc_util.msc_log('Before exception create table : ' ||l_temp_table);
9923:
9924: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9925: APPLICATION_SHORT_NAME => 'MSC',

Line 9922: msc_util.msc_log('Before exception create table : ' ||l_temp_table);

9918: STATEMENT => 'DROP TABLE ' || l_temp_table,
9919: OBJECT_NAME => l_temp_table);
9920:
9921: msc_util.msc_log('After Drop table : ' ||l_temp_table);
9922: msc_util.msc_log('Before exception create table : ' ||l_temp_table);
9923:
9924: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9925: APPLICATION_SHORT_NAME => 'MSC',
9926: STATEMENT_TYPE => ad_ddl.create_table,

Line 9929: msc_util.msc_log('After exception create table : ' ||l_temp_table);

9925: APPLICATION_SHORT_NAME => 'MSC',
9926: STATEMENT_TYPE => ad_ddl.create_table,
9927: STATEMENT => l_insert_stmt,
9928: OBJECT_NAME => l_temp_table);
9929: msc_util.msc_log('After exception create table : ' ||l_temp_table);
9930: END;
9931:
9932: /*--------------------------------------------------------------------------
9933: | <<<<<<<<<<<<<<<<<<<<<<< Begin Supplies SQL1 >>>>>>>>>>>>>>>>>>>>>>>>>>>

Line 9935: msc_util.msc_log('Before generating Supplies SQL1');

9931:
9932: /*--------------------------------------------------------------------------
9933: | <<<<<<<<<<<<<<<<<<<<<<< Begin Supplies SQL1 >>>>>>>>>>>>>>>>>>>>>>>>>>>
9934: +-------------------------------------------------------------------------*/
9935: msc_util.msc_log('Before generating Supplies SQL1');
9936:
9937: /* forecast at PF changes begin*/
9938: Prepare_Supplies_Stmt(l_share_partition, p_demand_priority, l_excess_supply_by_dc,
9939: l_temp_table, l_alloc_temp_table, l_parallel_degree, l_sql_stmt_1, l_return_status);

Line 9943: msc_util.msc_log('Pf_Post_Plan_Proc: ' || 'Error occured in procedure Prepare_Supplies_Stmt');

9939: l_temp_table, l_alloc_temp_table, l_parallel_degree, l_sql_stmt_1, l_return_status);
9940:
9941: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
9942: IF PG_DEBUG in ('Y', 'C') THEN
9943: msc_util.msc_log('Pf_Post_Plan_Proc: ' || 'Error occured in procedure Prepare_Supplies_Stmt');
9944: END IF;
9945: RAISE FND_API.G_EXC_ERROR;
9946: END IF;
9947:

Line 9948: msc_util.msc_log(l_sql_stmt_1);

9944: END IF;
9945: RAISE FND_API.G_EXC_ERROR;
9946: END IF;
9947:
9948: msc_util.msc_log(l_sql_stmt_1);
9949: msc_util.msc_log('After Generating Supplies SQL1');
9950:
9951: -- Parse cursor handler for sql_stmt: Don't open as its already opened
9952:

Line 9949: msc_util.msc_log('After Generating Supplies SQL1');

9945: RAISE FND_API.G_EXC_ERROR;
9946: END IF;
9947:
9948: msc_util.msc_log(l_sql_stmt_1);
9949: msc_util.msc_log('After Generating Supplies SQL1');
9950:
9951: -- Parse cursor handler for sql_stmt: Don't open as its already opened
9952:
9953: DBMS_SQL.PARSE(cur_handler, l_sql_stmt_1, DBMS_SQL.NATIVE);

Line 9954: msc_util.msc_log('After parsing Supplies SQL1');

9950:
9951: -- Parse cursor handler for sql_stmt: Don't open as its already opened
9952:
9953: DBMS_SQL.PARSE(cur_handler, l_sql_stmt_1, DBMS_SQL.NATIVE);
9954: msc_util.msc_log('After parsing Supplies SQL1');
9955:
9956: DBMS_SQL.BIND_VARIABLE(cur_handler, ':l_user_id', l_user_id);
9957: DBMS_SQL.BIND_VARIABLE(cur_handler, ':l_sysdate', l_sysdate);
9958: DBMS_SQL.BIND_VARIABLE(cur_handler, ':p_plan_id', p_plan_id);

Line 9967: msc_util.msc_log('after binding the variables');

9963: DBMS_SQL.BIND_VARIABLE(cur_handler, ':def_num', '-1');
9964: END IF;
9965: /* forecast at PF changes end*/
9966:
9967: msc_util.msc_log('after binding the variables');
9968:
9969: -- Execute the cursor
9970: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9971: msc_util.msc_log('After executing first supplies cursor');

Line 9971: msc_util.msc_log('After executing first supplies cursor');

9967: msc_util.msc_log('after binding the variables');
9968:
9969: -- Execute the cursor
9970: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9971: msc_util.msc_log('After executing first supplies cursor');
9972: msc_util.msc_log('after inserting item data into MSC_TEMP_ALLOC_SUPPLIES table');
9973:
9974: commit;
9975:

Line 9972: msc_util.msc_log('after inserting item data into MSC_TEMP_ALLOC_SUPPLIES table');

9968:
9969: -- Execute the cursor
9970: rows_processed := DBMS_SQL.EXECUTE(cur_handler);
9971: msc_util.msc_log('After executing first supplies cursor');
9972: msc_util.msc_log('after inserting item data into MSC_TEMP_ALLOC_SUPPLIES table');
9973:
9974: commit;
9975:
9976: msc_util.msc_log('before creating indexes on temp supply table');

Line 9976: msc_util.msc_log('before creating indexes on temp supply table');

9972: msc_util.msc_log('after inserting item data into MSC_TEMP_ALLOC_SUPPLIES table');
9973:
9974: commit;
9975:
9976: msc_util.msc_log('before creating indexes on temp supply table');
9977: l_sql_stmt_1 := 'CREATE INDEX ' || l_temp_table || '_N1 ON ' || l_temp_table || '
9978: -- NOLOGGING
9979: (plan_id, inventory_item_id, organization_id, sr_instance_id, demand_class, supply_date)
9980: STORAGE(INITIAL 40K NEXT 2M PCTINCREASE 0) tablespace ' || l_ind_tbspace;

Line 9982: msc_util.msc_log('Before index : ' || l_temp_table || '.' || l_temp_table || '_N1');

9978: -- NOLOGGING
9979: (plan_id, inventory_item_id, organization_id, sr_instance_id, demand_class, supply_date)
9980: STORAGE(INITIAL 40K NEXT 2M PCTINCREASE 0) tablespace ' || l_ind_tbspace;
9981:
9982: msc_util.msc_log('Before index : ' || l_temp_table || '.' || l_temp_table || '_N1');
9983:
9984: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
9985: APPLICATION_SHORT_NAME => 'MSC',
9986: STATEMENT_TYPE => ad_ddl.create_index,

Line 9990: msc_util.msc_log('After index : ' || l_temp_table || '.' || l_temp_table || '_N1');

9986: STATEMENT_TYPE => ad_ddl.create_index,
9987: STATEMENT => l_sql_stmt_1,
9988: OBJECT_NAME => l_temp_table);
9989:
9990: msc_util.msc_log('After index : ' || l_temp_table || '.' || l_temp_table || '_N1');
9991:
9992: l_sql_stmt_1 := 'CREATE INDEX ' || l_temp_table || '_N2 ON ' || l_temp_table || '
9993: -- NOLOGGING
9994: --Bug 3629191

Line 9999: msc_util.msc_log('Before index : ' || l_temp_table || '.' || l_temp_table || '_N2');

9995: (plan_id,
9996: parent_transaction_id)
9997: STORAGE(INITIAL 40K NEXT 2M PCTINCREASE 0) tablespace ' || l_ind_tbspace;
9998:
9999: msc_util.msc_log('Before index : ' || l_temp_table || '.' || l_temp_table || '_N2');
10000:
10001: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
10002: APPLICATION_SHORT_NAME => 'MSC',
10003: STATEMENT_TYPE => ad_ddl.create_index,

Line 10007: msc_util.msc_log('After index : ' || l_temp_table || '.' || l_temp_table || '_N2');

10003: STATEMENT_TYPE => ad_ddl.create_index,
10004: STATEMENT => l_sql_stmt_1,
10005: OBJECT_NAME => l_temp_table);
10006:
10007: msc_util.msc_log('After index : ' || l_temp_table || '.' || l_temp_table || '_N2');
10008:
10009: l_sql_stmt_1 := 'CREATE INDEX ' || l_temp_table || '_N3 ON ' || l_temp_table || '
10010: -- NOLOGGING
10011: --Bug 3629191

Line 10016: msc_util.msc_log('Before index : ' || l_temp_table || '.' || l_temp_table || '_N3');

10012: (plan_id,
10013: sales_order_line_id)
10014: STORAGE(INITIAL 40K NEXT 2M PCTINCREASE 0) tablespace ' || l_ind_tbspace;
10015:
10016: msc_util.msc_log('Before index : ' || l_temp_table || '.' || l_temp_table || '_N3');
10017:
10018: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
10019: APPLICATION_SHORT_NAME => 'MSC',
10020: STATEMENT_TYPE => ad_ddl.create_index,

Line 10024: msc_util.msc_log('After index : ' || l_temp_table || '.' || l_temp_table || '_N3');

10020: STATEMENT_TYPE => ad_ddl.create_index,
10021: STATEMENT => l_sql_stmt_1,
10022: OBJECT_NAME => l_temp_table);
10023:
10024: msc_util.msc_log('After index : ' || l_temp_table || '.' || l_temp_table || '_N3');
10025:
10026: msc_util.msc_log('Gather Table Stats for Allocated S/D Tables');
10027:
10028: fnd_stats.gather_table_stats(l_msc_schema, 'MSC_TEMP_ALLOC_DEM_' || to_char(l_plan_id), granularity => 'ALL');

Line 10026: msc_util.msc_log('Gather Table Stats for Allocated S/D Tables');

10022: OBJECT_NAME => l_temp_table);
10023:
10024: msc_util.msc_log('After index : ' || l_temp_table || '.' || l_temp_table || '_N3');
10025:
10026: msc_util.msc_log('Gather Table Stats for Allocated S/D Tables');
10027:
10028: fnd_stats.gather_table_stats(l_msc_schema, 'MSC_TEMP_ALLOC_DEM_' || to_char(l_plan_id), granularity => 'ALL');
10029: fnd_stats.gather_table_stats(l_msc_schema, 'MSC_TEMP_ALLOC_SUP_' || to_char(l_plan_id), granularity => 'ALL');
10030:

Line 10031: msc_util.msc_log('swap partition for demands');

10027:
10028: fnd_stats.gather_table_stats(l_msc_schema, 'MSC_TEMP_ALLOC_DEM_' || to_char(l_plan_id), granularity => 'ALL');
10029: fnd_stats.gather_table_stats(l_msc_schema, 'MSC_TEMP_ALLOC_SUP_' || to_char(l_plan_id), granularity => 'ALL');
10030:
10031: msc_util.msc_log('swap partition for demands');
10032: l_partition_name := 'ALLOC_DEMANDS_' || to_char(l_plan_id);
10033:
10034: msc_util.msc_log('Partition name for msc_alloc_demands table : ' || l_partition_name);
10035:

Line 10034: msc_util.msc_log('Partition name for msc_alloc_demands table : ' || l_partition_name);

10030:
10031: msc_util.msc_log('swap partition for demands');
10032: l_partition_name := 'ALLOC_DEMANDS_' || to_char(l_plan_id);
10033:
10034: msc_util.msc_log('Partition name for msc_alloc_demands table : ' || l_partition_name);
10035:
10036: -- swap partiton for supplies and demand part
10037:
10038: l_sql_stmt := 'ALTER TABLE msc_alloc_demands EXCHANGE PARTITION ' || l_partition_name ||

Line 10043: msc_util.msc_log('Before alter table msc_alloc_demands');

10039: ' with table MSC_TEMP_ALLOC_DEM_'|| to_char(l_plan_id) ||
10040: ' including indexes without validation';
10041:
10042: BEGIN
10043: msc_util.msc_log('Before alter table msc_alloc_demands');
10044: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
10045: APPLICATION_SHORT_NAME => 'MSC',
10046: STATEMENT_TYPE => ad_ddl.alter_table,
10047: STATEMENT => l_sql_stmt,

Line 10051: msc_util.msc_log('swap partition for supplies');

10047: STATEMENT => l_sql_stmt,
10048: OBJECT_NAME => 'MSC_ALLOC_DEMANDS');
10049: END;
10050:
10051: msc_util.msc_log('swap partition for supplies');
10052: l_partition_name := 'ALLOC_SUPPLIES_' || to_char(l_plan_id);
10053:
10054: msc_util.msc_log('Partition name for msc_alloc_supplies table : ' || l_partition_name);
10055:

Line 10054: msc_util.msc_log('Partition name for msc_alloc_supplies table : ' || l_partition_name);

10050:
10051: msc_util.msc_log('swap partition for supplies');
10052: l_partition_name := 'ALLOC_SUPPLIES_' || to_char(l_plan_id);
10053:
10054: msc_util.msc_log('Partition name for msc_alloc_supplies table : ' || l_partition_name);
10055:
10056: l_sql_stmt := 'ALTER TABLE msc_alloc_supplies EXCHANGE PARTITION ' || l_partition_name ||
10057: ' with table MSC_TEMP_ALLOC_SUP_'|| to_char(l_plan_id) ||
10058: ' including indexes without validation';

Line 10061: msc_util.msc_log('Before alter table msc_alloc_supplies');

10057: ' with table MSC_TEMP_ALLOC_SUP_'|| to_char(l_plan_id) ||
10058: ' including indexes without validation';
10059:
10060: BEGIN
10061: msc_util.msc_log('Before alter table msc_alloc_supplies');
10062: ad_ddl.do_ddl(APPLSYS_SCHEMA => l_applsys_schema,
10063: APPLICATION_SHORT_NAME => 'MSC',
10064: STATEMENT_TYPE => ad_ddl.alter_table,
10065: STATEMENT => l_sql_stmt,

Line 10073: msc_util.msc_log('Call procedure clean_temp_tables');

10069: END IF; -- IF l_share_partition = 'Y'
10070:
10071: /* forecast at PF changes begin*/
10072: -- clean temp tables after exchanging partitions
10073: msc_util.msc_log('Call procedure clean_temp_tables');
10074:
10075: MSC_POST_PRO.clean_temp_tables(l_applsys_schema, l_plan_id, p_plan_id, p_demand_priority);
10076:
10077: msc_util.msc_log('After procedure clean_temp_tables');

Line 10077: msc_util.msc_log('After procedure clean_temp_tables');

10073: msc_util.msc_log('Call procedure clean_temp_tables');
10074:
10075: MSC_POST_PRO.clean_temp_tables(l_applsys_schema, l_plan_id, p_plan_id, p_demand_priority);
10076:
10077: msc_util.msc_log('After procedure clean_temp_tables');
10078: /* forecast at PF changes end*/
10079:
10080: /* Call Update_Pf_Display_Flags to update Pf_Display_Flag in msc_alloc_demands*/
10081: Update_Pf_Display_Flag(p_plan_id, l_return_status);

Line 10085: msc_util.msc_log('Pf_Post_Plan_Proc: ' || 'Error occured in procedure Update_Pf_Display_Flag');

10081: Update_Pf_Display_Flag(p_plan_id, l_return_status);
10082:
10083: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
10084: IF PG_DEBUG in ('Y', 'C') THEN
10085: msc_util.msc_log('Pf_Post_Plan_Proc: ' || 'Error occured in procedure Update_Pf_Display_Flag');
10086: END IF;
10087: RAISE FND_API.G_EXC_ERROR;
10088: END IF;
10089:

Line 10099: msc_util.msc_log('End procedure Pf_Post_Plan_Proc');

10095:
10096: RETCODE := G_SUCCESS;
10097: commit;
10098:
10099: msc_util.msc_log('End procedure Pf_Post_Plan_Proc');
10100:
10101: EXCEPTION
10102: WHEN OTHERS THEN
10103: msc_util.msc_log('Inside main exception of Pf_Post_Plan_Proc');

Line 10103: msc_util.msc_log('Inside main exception of Pf_Post_Plan_Proc');

10099: msc_util.msc_log('End procedure Pf_Post_Plan_Proc');
10100:
10101: EXCEPTION
10102: WHEN OTHERS THEN
10103: msc_util.msc_log('Inside main exception of Pf_Post_Plan_Proc');
10104: msc_util.msc_log(sqlerrm);
10105: ERRBUF := sqlerrm;
10106:
10107: BEGIN

Line 10104: msc_util.msc_log(sqlerrm);

10100:
10101: EXCEPTION
10102: WHEN OTHERS THEN
10103: msc_util.msc_log('Inside main exception of Pf_Post_Plan_Proc');
10104: msc_util.msc_log(sqlerrm);
10105: ERRBUF := sqlerrm;
10106:
10107: BEGIN
10108: update msc_plans

Line 10118: msc_util.msc_log('Call procedure clean_temp_tables in exception');

10114: RETCODE := G_ERROR;
10115: IF (l_share_partition = 'Y') THEN
10116: ROLLBACK;
10117: ELSE
10118: msc_util.msc_log('Call procedure clean_temp_tables in exception');
10119:
10120: /* forecast at PF changes*/
10121: MSC_POST_PRO.clean_temp_tables(l_applsys_schema, l_plan_id, p_plan_id, p_demand_priority);
10122:

Line 10123: msc_util.msc_log('After procedure clean_temp_tables in exception');

10119:
10120: /* forecast at PF changes*/
10121: MSC_POST_PRO.clean_temp_tables(l_applsys_schema, l_plan_id, p_plan_id, p_demand_priority);
10122:
10123: msc_util.msc_log('After procedure clean_temp_tables in exception');
10124: END IF;
10125: END Pf_Post_Plan_Proc;
10126:
10127: -- New private procedure added for forecast at PF

Line 10153: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_share_partition : ' || p_share_partition);

10149:
10150: BEGIN
10151:
10152: IF PG_DEBUG in ('Y', 'C') THEN
10153: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_share_partition : ' || p_share_partition);
10154: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_demand_priority : ' || p_demand_priority);
10155: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10156: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_temp_table : ' || p_temp_table);
10157: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);

Line 10154: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_demand_priority : ' || p_demand_priority);

10150: BEGIN
10151:
10152: IF PG_DEBUG in ('Y', 'C') THEN
10153: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_share_partition : ' || p_share_partition);
10154: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_demand_priority : ' || p_demand_priority);
10155: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10156: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_temp_table : ' || p_temp_table);
10157: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);
10158: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_parallel_degree : ' || p_parallel_degree);

Line 10155: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);

10151:
10152: IF PG_DEBUG in ('Y', 'C') THEN
10153: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_share_partition : ' || p_share_partition);
10154: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_demand_priority : ' || p_demand_priority);
10155: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10156: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_temp_table : ' || p_temp_table);
10157: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);
10158: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_parallel_degree : ' || p_parallel_degree);
10159: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'MSC_ATP_PVT.G_HP_DEMAND_BUCKETING_PREF : ' || MSC_ATP_PVT.G_HP_DEMAND_BUCKETING_PREF);

Line 10156: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_temp_table : ' || p_temp_table);

10152: IF PG_DEBUG in ('Y', 'C') THEN
10153: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_share_partition : ' || p_share_partition);
10154: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_demand_priority : ' || p_demand_priority);
10155: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10156: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_temp_table : ' || p_temp_table);
10157: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);
10158: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_parallel_degree : ' || p_parallel_degree);
10159: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'MSC_ATP_PVT.G_HP_DEMAND_BUCKETING_PREF : ' || MSC_ATP_PVT.G_HP_DEMAND_BUCKETING_PREF);
10160: END IF;

Line 10157: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);

10153: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_share_partition : ' || p_share_partition);
10154: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_demand_priority : ' || p_demand_priority);
10155: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10156: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_temp_table : ' || p_temp_table);
10157: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);
10158: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_parallel_degree : ' || p_parallel_degree);
10159: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'MSC_ATP_PVT.G_HP_DEMAND_BUCKETING_PREF : ' || MSC_ATP_PVT.G_HP_DEMAND_BUCKETING_PREF);
10160: END IF;
10161:

Line 10158: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_parallel_degree : ' || p_parallel_degree);

10154: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_demand_priority : ' || p_demand_priority);
10155: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10156: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_temp_table : ' || p_temp_table);
10157: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);
10158: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_parallel_degree : ' || p_parallel_degree);
10159: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'MSC_ATP_PVT.G_HP_DEMAND_BUCKETING_PREF : ' || MSC_ATP_PVT.G_HP_DEMAND_BUCKETING_PREF);
10160: END IF;
10161:
10162: -- Initializing API return code

Line 10159: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'MSC_ATP_PVT.G_HP_DEMAND_BUCKETING_PREF : ' || MSC_ATP_PVT.G_HP_DEMAND_BUCKETING_PREF);

10155: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10156: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_temp_table : ' || p_temp_table);
10157: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);
10158: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'p_parallel_degree : ' || p_parallel_degree);
10159: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'MSC_ATP_PVT.G_HP_DEMAND_BUCKETING_PREF : ' || MSC_ATP_PVT.G_HP_DEMAND_BUCKETING_PREF);
10160: END IF;
10161:
10162: -- Initializing API return code
10163: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 10560: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'Error occurred: ' || to_char(sqlcode) || ':' || SQLERRM);

10556:
10557: EXCEPTION
10558: WHEN OTHERS THEN
10559: IF PG_DEBUG in ('Y', 'C') THEN
10560: msc_util.msc_log('Prepare_Demands_Stmt: ' || 'Error occurred: ' || to_char(sqlcode) || ':' || SQLERRM);
10561: END IF;
10562: x_return_status := FND_API.G_RET_STS_ERROR;
10563:
10564: END Prepare_Demands_Stmt;

Line 10592: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_share_partition : ' || p_share_partition);

10588:
10589: BEGIN
10590:
10591: IF PG_DEBUG in ('Y', 'C') THEN
10592: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_share_partition : ' || p_share_partition);
10593: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_demand_priority : ' || p_demand_priority);
10594: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10595: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_temp_table : ' || p_temp_table);
10596: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);

Line 10593: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_demand_priority : ' || p_demand_priority);

10589: BEGIN
10590:
10591: IF PG_DEBUG in ('Y', 'C') THEN
10592: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_share_partition : ' || p_share_partition);
10593: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_demand_priority : ' || p_demand_priority);
10594: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10595: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_temp_table : ' || p_temp_table);
10596: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);
10597: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_parallel_degree : ' || p_parallel_degree);

Line 10594: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);

10590:
10591: IF PG_DEBUG in ('Y', 'C') THEN
10592: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_share_partition : ' || p_share_partition);
10593: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_demand_priority : ' || p_demand_priority);
10594: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10595: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_temp_table : ' || p_temp_table);
10596: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);
10597: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_parallel_degree : ' || p_parallel_degree);
10598: END IF;

Line 10595: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_temp_table : ' || p_temp_table);

10591: IF PG_DEBUG in ('Y', 'C') THEN
10592: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_share_partition : ' || p_share_partition);
10593: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_demand_priority : ' || p_demand_priority);
10594: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10595: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_temp_table : ' || p_temp_table);
10596: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);
10597: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_parallel_degree : ' || p_parallel_degree);
10598: END IF;
10599:

Line 10596: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);

10592: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_share_partition : ' || p_share_partition);
10593: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_demand_priority : ' || p_demand_priority);
10594: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10595: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_temp_table : ' || p_temp_table);
10596: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);
10597: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_parallel_degree : ' || p_parallel_degree);
10598: END IF;
10599:
10600: -- Initializing API return code

Line 10597: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_parallel_degree : ' || p_parallel_degree);

10593: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_demand_priority : ' || p_demand_priority);
10594: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10595: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_temp_table : ' || p_temp_table);
10596: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_alloc_temp_table : ' || p_alloc_temp_table);
10597: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'p_parallel_degree : ' || p_parallel_degree);
10598: END IF;
10599:
10600: -- Initializing API return code
10601: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 10792: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'Error occurred: ' || to_char(sqlcode) || ':' || SQLERRM);

10788:
10789: EXCEPTION
10790: WHEN OTHERS THEN
10791: IF PG_DEBUG in ('Y', 'C') THEN
10792: msc_util.msc_log('Prepare_Supplies_Stmt: ' || 'Error occurred: ' || to_char(sqlcode) || ':' || SQLERRM);
10793: END IF;
10794: x_return_status := FND_API.G_RET_STS_ERROR;
10795:
10796: END Prepare_Supplies_Stmt;

Line 10823: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_share_partition : ' || p_share_partition);

10819:
10820: BEGIN
10821:
10822: IF PG_DEBUG in ('Y', 'C') THEN
10823: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_share_partition : ' || p_share_partition);
10824: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_demand_priority : ' || p_demand_priority);
10825: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10826: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_temp_table : ' || p_temp_table);
10827: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_parallel_degree : ' || p_parallel_degree);

Line 10824: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_demand_priority : ' || p_demand_priority);

10820: BEGIN
10821:
10822: IF PG_DEBUG in ('Y', 'C') THEN
10823: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_share_partition : ' || p_share_partition);
10824: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_demand_priority : ' || p_demand_priority);
10825: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10826: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_temp_table : ' || p_temp_table);
10827: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_parallel_degree : ' || p_parallel_degree);
10828: END IF;

Line 10825: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);

10821:
10822: IF PG_DEBUG in ('Y', 'C') THEN
10823: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_share_partition : ' || p_share_partition);
10824: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_demand_priority : ' || p_demand_priority);
10825: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10826: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_temp_table : ' || p_temp_table);
10827: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_parallel_degree : ' || p_parallel_degree);
10828: END IF;
10829:

Line 10826: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_temp_table : ' || p_temp_table);

10822: IF PG_DEBUG in ('Y', 'C') THEN
10823: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_share_partition : ' || p_share_partition);
10824: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_demand_priority : ' || p_demand_priority);
10825: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10826: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_temp_table : ' || p_temp_table);
10827: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_parallel_degree : ' || p_parallel_degree);
10828: END IF;
10829:
10830: -- Initializing API return code

Line 10827: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_parallel_degree : ' || p_parallel_degree);

10823: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_share_partition : ' || p_share_partition);
10824: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_demand_priority : ' || p_demand_priority);
10825: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_excess_supply_by_dc : ' || p_excess_supply_by_dc);
10826: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_temp_table : ' || p_temp_table);
10827: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'p_parallel_degree : ' || p_parallel_degree);
10828: END IF;
10829:
10830: -- Initializing API return code
10831: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 11430: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'Error occurred: ' || to_char(sqlcode) || ':' || SQLERRM);

11426:
11427: EXCEPTION
11428: WHEN OTHERS THEN
11429: IF PG_DEBUG in ('Y', 'C') THEN
11430: msc_util.msc_log('Prepare_Demands_Stmt1: ' || 'Error occurred: ' || to_char(sqlcode) || ':' || SQLERRM);
11431: END IF;
11432: x_return_status := FND_API.G_RET_STS_ERROR;
11433:
11434: END Prepare_Demands_Stmt1;

Line 11658: msc_util.msc_log('Prepare_Demands_Stmt2: ' || 'Error occurred: ' || to_char(sqlcode) || ':' || SQLERRM);

11654:
11655: EXCEPTION
11656: WHEN OTHERS THEN
11657: IF PG_DEBUG in ('Y', 'C') THEN
11658: msc_util.msc_log('Prepare_Demands_Stmt2: ' || 'Error occurred: ' || to_char(sqlcode) || ':' || SQLERRM);
11659: END IF;
11660: x_return_status := FND_API.G_RET_STS_ERROR;
11661:
11662: END Prepare_Demands_Stmt2;

Line 11986: msc_util.msc_log('Prepare_Supplies_Stmt1: ' || 'Error occurred: ' || to_char(sqlcode) || ':' || SQLERRM);

11982:
11983: EXCEPTION
11984: WHEN OTHERS THEN
11985: IF PG_DEBUG in ('Y', 'C') THEN
11986: msc_util.msc_log('Prepare_Supplies_Stmt1: ' || 'Error occurred: ' || to_char(sqlcode) || ':' || SQLERRM);
11987: END IF;
11988: x_return_status := FND_API.G_RET_STS_ERROR;
11989:
11990: END Prepare_Supplies_Stmt1;

Line 12149: msc_util.msc_log('Prepare_Supplies_Stmt2: ' || 'Error occurred: ' || to_char(sqlcode) || ':' || SQLERRM);

12145:
12146: EXCEPTION
12147: WHEN OTHERS THEN
12148: IF PG_DEBUG in ('Y', 'C') THEN
12149: msc_util.msc_log('Prepare_Supplies_Stmt2: ' || 'Error occurred: ' || to_char(sqlcode) || ':' || SQLERRM);
12150: END IF;
12151: x_return_status := FND_API.G_RET_STS_ERROR;
12152:
12153: END Prepare_Supplies_Stmt2;

Line 12169: msc_util.msc_log('Update_Pf_Display_Flag: ' || 'p_plan_id: ' || p_plan_id);

12165: l_return_status VARCHAR2(1);
12166:
12167: BEGIN
12168: IF PG_DEBUG in ('Y', 'C') THEN
12169: msc_util.msc_log('Update_Pf_Display_Flag: ' || 'p_plan_id: ' || p_plan_id);
12170: END IF;
12171:
12172: -- Initializing API return code
12173: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 12218: msc_util.msc_log('Update_Pf_Display_Flag: ' || 'Error occurred: ' || to_char(sqlcode) || ':' || SQLERRM);

12214: AND I.aggregate_time_fence_date is not null);
12215: EXCEPTION
12216: WHEN OTHERS THEN
12217: IF PG_DEBUG in ('Y', 'C') THEN
12218: msc_util.msc_log('Update_Pf_Display_Flag: ' || 'Error occurred: ' || to_char(sqlcode) || ':' || SQLERRM);
12219: END IF;
12220: x_return_status := FND_API.G_RET_STS_ERROR;
12221:
12222: END Update_Pf_Display_Flag;