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.FND_OAM_DSCRAM_ARGS_PKG dependencies on FND_OAM_DSCRAM_UTILS_PKG

Line 30: RETURN p_arg.permissions IN (FND_OAM_DSCRAM_UTILS_PKG.G_PERMISSION_READ,

26: FUNCTION IS_READABLE(p_arg IN arg)
27: RETURN BOOLEAN
28: IS
29: BEGIN
30: RETURN p_arg.permissions IN (FND_OAM_DSCRAM_UTILS_PKG.G_PERMISSION_READ,
31: FND_OAM_DSCRAM_UTILS_PKG.G_PERMISSION_READ_WRITE);
32: END;
33:
34: -- Public

Line 31: FND_OAM_DSCRAM_UTILS_PKG.G_PERMISSION_READ_WRITE);

27: RETURN BOOLEAN
28: IS
29: BEGIN
30: RETURN p_arg.permissions IN (FND_OAM_DSCRAM_UTILS_PKG.G_PERMISSION_READ,
31: FND_OAM_DSCRAM_UTILS_PKG.G_PERMISSION_READ_WRITE);
32: END;
33:
34: -- Public
35: FUNCTION IS_WRITABLE(p_arg IN arg)

Line 39: RETURN p_arg.permissions IN (FND_OAM_DSCRAM_UTILS_PKG.G_PERMISSION_WRITE,

35: FUNCTION IS_WRITABLE(p_arg IN arg)
36: RETURN BOOLEAN
37: IS
38: BEGIN
39: RETURN p_arg.permissions IN (FND_OAM_DSCRAM_UTILS_PKG.G_PERMISSION_WRITE,
40: FND_OAM_DSCRAM_UTILS_PKG.G_PERMISSION_READ_WRITE);
41: END;
42:
43: -- Private helper to make sure a canonical value is proper for an arg,

Line 40: FND_OAM_DSCRAM_UTILS_PKG.G_PERMISSION_READ_WRITE);

36: RETURN BOOLEAN
37: IS
38: BEGIN
39: RETURN p_arg.permissions IN (FND_OAM_DSCRAM_UTILS_PKG.G_PERMISSION_WRITE,
40: FND_OAM_DSCRAM_UTILS_PKG.G_PERMISSION_READ_WRITE);
41: END;
42:
43: -- Private helper to make sure a canonical value is proper for an arg,
44: -- validation failures are returned as exceptions

Line 55: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN

51: l_date DATE;
52: l_rowid ROWID;
53: BEGIN
54: CASE p_arg.datatype
55: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN
56: null; --no validation
57: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN
58: l_num := FND_NUMBER.CANONICAL_TO_NUMBER(p_canonical_value);
59: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN

Line 57: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN

53: BEGIN
54: CASE p_arg.datatype
55: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN
56: null; --no validation
57: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN
58: l_num := FND_NUMBER.CANONICAL_TO_NUMBER(p_canonical_value);
59: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN
60: l_date := FND_DATE.CANONICAL_TO_DATE(p_canonical_value);
61: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN

Line 59: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN

55: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN
56: null; --no validation
57: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN
58: l_num := FND_NUMBER.CANONICAL_TO_NUMBER(p_canonical_value);
59: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN
60: l_date := FND_DATE.CANONICAL_TO_DATE(p_canonical_value);
61: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN
62: --for some reason, this is refusing to throw an exception on invalid values
63: l_rowid := CHARTOROWID(p_canonical_value);

Line 61: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN

57: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN
58: l_num := FND_NUMBER.CANONICAL_TO_NUMBER(p_canonical_value);
59: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN
60: l_date := FND_DATE.CANONICAL_TO_DATE(p_canonical_value);
61: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN
62: --for some reason, this is refusing to throw an exception on invalid values
63: l_rowid := CHARTOROWID(p_canonical_value);
64: ELSE
65: --unknown datatype

Line 102: l_initialized BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_initialized_success_flag);

98: RETURN arg
99: IS
100: l_ctxt VARCHAR2(60) := PKG_NAME||'INTERNAL_CREATE_ARG';
101:
102: l_initialized BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_initialized_success_flag);
103: l_allow_override_source BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_allow_override_source_flag);
104: l_binding_enabled BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_binding_enabled_flag);
105: l_valid_value BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_valid_value_flag);
106:

Line 103: l_allow_override_source BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_allow_override_source_flag);

99: IS
100: l_ctxt VARCHAR2(60) := PKG_NAME||'INTERNAL_CREATE_ARG';
101:
102: l_initialized BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_initialized_success_flag);
103: l_allow_override_source BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_allow_override_source_flag);
104: l_binding_enabled BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_binding_enabled_flag);
105: l_valid_value BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_valid_value_flag);
106:
107: l_arg arg;

Line 104: l_binding_enabled BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_binding_enabled_flag);

100: l_ctxt VARCHAR2(60) := PKG_NAME||'INTERNAL_CREATE_ARG';
101:
102: l_initialized BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_initialized_success_flag);
103: l_allow_override_source BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_allow_override_source_flag);
104: l_binding_enabled BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_binding_enabled_flag);
105: l_valid_value BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_valid_value_flag);
106:
107: l_arg arg;
108: l_ignore VARCHAR2(2048);

Line 105: l_valid_value BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_valid_value_flag);

101:
102: l_initialized BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_initialized_success_flag);
103: l_allow_override_source BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_allow_override_source_flag);
104: l_binding_enabled BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_binding_enabled_flag);
105: l_valid_value BOOLEAN := FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_valid_value_flag);
106:
107: l_arg arg;
108: l_ignore VARCHAR2(2048);
109: BEGIN

Line 218: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_RUN_ID THEN

214: x_return_msg := '';
215:
216: --do a big case statement on the state key to fetch the value
217: CASE p_state_key
218: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_RUN_ID THEN
219: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_RUNS_PKG.GET_RUN_ID);
220:
221: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_RUN_MODE THEN
222: l_canonical_value := FND_OAM_DSCRAM_RUNS_PKG.GET_RUN_MODE;

Line 221: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_RUN_MODE THEN

217: CASE p_state_key
218: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_RUN_ID THEN
219: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_RUNS_PKG.GET_RUN_ID);
220:
221: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_RUN_MODE THEN
222: l_canonical_value := FND_OAM_DSCRAM_RUNS_PKG.GET_RUN_MODE;
223:
224: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BUNDLE_ID THEN
225: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_BUNDLES_PKG.GET_BUNDLE_ID);

Line 224: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BUNDLE_ID THEN

220:
221: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_RUN_MODE THEN
222: l_canonical_value := FND_OAM_DSCRAM_RUNS_PKG.GET_RUN_MODE;
223:
224: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BUNDLE_ID THEN
225: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_BUNDLES_PKG.GET_BUNDLE_ID);
226:
227: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BUNDLE_WORKERS_ALLOWED THEN
228: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_BUNDLES_PKG.GET_WORKERS_ALLOWED);

Line 227: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BUNDLE_WORKERS_ALLOWED THEN

223:
224: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BUNDLE_ID THEN
225: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_BUNDLES_PKG.GET_BUNDLE_ID);
226:
227: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BUNDLE_WORKERS_ALLOWED THEN
228: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_BUNDLES_PKG.GET_WORKERS_ALLOWED);
229:
230: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BUNDLE_BATCH_SIZE THEN
231: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_BUNDLES_PKG.GET_BATCH_SIZE);

Line 230: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BUNDLE_BATCH_SIZE THEN

226:
227: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BUNDLE_WORKERS_ALLOWED THEN
228: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_BUNDLES_PKG.GET_WORKERS_ALLOWED);
229:
230: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BUNDLE_BATCH_SIZE THEN
231: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_BUNDLES_PKG.GET_BATCH_SIZE);
232:
233: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_WORKER_ID THEN
234: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_BUNDLES_PKG.GET_WORKER_ID);

Line 233: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_WORKER_ID THEN

229:
230: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BUNDLE_BATCH_SIZE THEN
231: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_BUNDLES_PKG.GET_BATCH_SIZE);
232:
233: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_WORKER_ID THEN
234: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_BUNDLES_PKG.GET_WORKER_ID);
235:
236: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_TASK_ID THEN
237: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_TASKS_PKG.GET_TASK_ID);

Line 236: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_TASK_ID THEN

232:
233: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_WORKER_ID THEN
234: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_BUNDLES_PKG.GET_WORKER_ID);
235:
236: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_TASK_ID THEN
237: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_TASKS_PKG.GET_TASK_ID);
238:
239: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_ID THEN
240: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_UNITS_PKG.GET_UNIT_ID);

Line 239: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_ID THEN

235:
236: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_TASK_ID THEN
237: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_TASKS_PKG.GET_TASK_ID);
238:
239: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_ID THEN
240: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_UNITS_PKG.GET_UNIT_ID);
241:
242: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_USING_SPLITTING THEN
243: l_canonical_value := FND_OAM_DSCRAM_UTILS_PKG.BOOLEAN_TO_FLAG(p_using_splitting);

Line 242: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_USING_SPLITTING THEN

238:
239: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_ID THEN
240: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_UNITS_PKG.GET_UNIT_ID);
241:
242: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_USING_SPLITTING THEN
243: l_canonical_value := FND_OAM_DSCRAM_UTILS_PKG.BOOLEAN_TO_FLAG(p_using_splitting);
244:
245: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_ROWID_LBOUND THEN
246: l_canonical_value := ROWIDTOCHAR(p_rowid_lbound);

Line 243: l_canonical_value := FND_OAM_DSCRAM_UTILS_PKG.BOOLEAN_TO_FLAG(p_using_splitting);

239: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_ID THEN
240: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_UNITS_PKG.GET_UNIT_ID);
241:
242: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_USING_SPLITTING THEN
243: l_canonical_value := FND_OAM_DSCRAM_UTILS_PKG.BOOLEAN_TO_FLAG(p_using_splitting);
244:
245: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_ROWID_LBOUND THEN
246: l_canonical_value := ROWIDTOCHAR(p_rowid_lbound);
247:

Line 245: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_ROWID_LBOUND THEN

241:
242: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_USING_SPLITTING THEN
243: l_canonical_value := FND_OAM_DSCRAM_UTILS_PKG.BOOLEAN_TO_FLAG(p_using_splitting);
244:
245: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_ROWID_LBOUND THEN
246: l_canonical_value := ROWIDTOCHAR(p_rowid_lbound);
247:
248: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_ROWID_UBOUND THEN
249: l_canonical_value := ROWIDTOCHAR(p_rowid_ubound);

Line 248: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_ROWID_UBOUND THEN

244:
245: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_ROWID_LBOUND THEN
246: l_canonical_value := ROWIDTOCHAR(p_rowid_lbound);
247:
248: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_ROWID_UBOUND THEN
249: l_canonical_value := ROWIDTOCHAR(p_rowid_ubound);
250:
251: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_OBJECT_OWNER THEN
252: l_canonical_value := FND_OAM_DSCRAM_UNITS_PKG.GET_UNIT_OBJECT_OWNER;

Line 251: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_OBJECT_OWNER THEN

247:
248: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_ROWID_UBOUND THEN
249: l_canonical_value := ROWIDTOCHAR(p_rowid_ubound);
250:
251: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_OBJECT_OWNER THEN
252: l_canonical_value := FND_OAM_DSCRAM_UNITS_PKG.GET_UNIT_OBJECT_OWNER;
253:
254: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_OBJECT_NAME THEN
255: l_canonical_value := FND_OAM_DSCRAM_UNITS_PKG.GET_UNIT_OBJECT_NAME;

Line 254: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_OBJECT_NAME THEN

250:
251: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_OBJECT_OWNER THEN
252: l_canonical_value := FND_OAM_DSCRAM_UNITS_PKG.GET_UNIT_OBJECT_OWNER;
253:
254: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_OBJECT_NAME THEN
255: l_canonical_value := FND_OAM_DSCRAM_UNITS_PKG.GET_UNIT_OBJECT_NAME;
256:
257: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_WORKERS_ALLOWED THEN
258: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_UNITS_PKG.GET_WORKERS_ALLOWED);

Line 257: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_WORKERS_ALLOWED THEN

253:
254: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_OBJECT_NAME THEN
255: l_canonical_value := FND_OAM_DSCRAM_UNITS_PKG.GET_UNIT_OBJECT_NAME;
256:
257: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_WORKERS_ALLOWED THEN
258: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_UNITS_PKG.GET_WORKERS_ALLOWED);
259:
260: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_BATCH_SIZE THEN
261: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_UNITS_PKG.GET_BATCH_SIZE);

Line 260: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_BATCH_SIZE THEN

256:
257: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_WORKERS_ALLOWED THEN
258: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_UNITS_PKG.GET_WORKERS_ALLOWED);
259:
260: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_BATCH_SIZE THEN
261: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_UNITS_PKG.GET_BATCH_SIZE);
262:
263: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_DML_ID THEN
264: l_canonical_value := FND_OAM_DSCRAM_DMLS_PKG.GET_CURRENT_DML_ID;

Line 263: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_DML_ID THEN

259:
260: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_UNIT_BATCH_SIZE THEN
261: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(FND_OAM_DSCRAM_UNITS_PKG.GET_BATCH_SIZE);
262:
263: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_DML_ID THEN
264: l_canonical_value := FND_OAM_DSCRAM_DMLS_PKG.GET_CURRENT_DML_ID;
265:
266: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_PLSQL_ID THEN
267: l_canonical_value := FND_OAM_DSCRAM_PLSQLS_PKG.GET_CURRENT_PLSQL_ID;

Line 266: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_PLSQL_ID THEN

262:
263: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_DML_ID THEN
264: l_canonical_value := FND_OAM_DSCRAM_DMLS_PKG.GET_CURRENT_DML_ID;
265:
266: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_PLSQL_ID THEN
267: l_canonical_value := FND_OAM_DSCRAM_PLSQLS_PKG.GET_CURRENT_PLSQL_ID;
268:
269: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_ARGUMENT_ID THEN
270: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(px_arg.arg_id);

Line 269: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_ARGUMENT_ID THEN

265:
266: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_PLSQL_ID THEN
267: l_canonical_value := FND_OAM_DSCRAM_PLSQLS_PKG.GET_CURRENT_PLSQL_ID;
268:
269: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_ARGUMENT_ID THEN
270: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(px_arg.arg_id);
271:
272: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_WORKERS_ALLOWED THEN
273: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(NVL(FND_OAM_DSCRAM_UNITS_PKG.GET_WORKERS_ALLOWED,

Line 272: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_WORKERS_ALLOWED THEN

268:
269: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_ARGUMENT_ID THEN
270: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(px_arg.arg_id);
271:
272: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_WORKERS_ALLOWED THEN
273: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(NVL(FND_OAM_DSCRAM_UNITS_PKG.GET_WORKERS_ALLOWED,
274: FND_OAM_DSCRAM_BUNDLES_PKG.GET_WORKERS_ALLOWED));
275:
276: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BATCH_SIZE THEN

Line 276: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BATCH_SIZE THEN

272: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_WORKERS_ALLOWED THEN
273: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(NVL(FND_OAM_DSCRAM_UNITS_PKG.GET_WORKERS_ALLOWED,
274: FND_OAM_DSCRAM_BUNDLES_PKG.GET_WORKERS_ALLOWED));
275:
276: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_KEY_BATCH_SIZE THEN
277: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(NVL(FND_OAM_DSCRAM_UNITS_PKG.GET_BATCH_SIZE,
278: FND_OAM_DSCRAM_BUNDLES_PKG.GET_BATCH_SIZE));
279: ELSE
280: x_return_msg := 'ARG ID('||px_arg.arg_id||'), invalid state key: '||p_state_key;

Line 293: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_MISSING_STATE;

289: fnd_oam_debug.log(2, l_ctxt, 'EXIT');
290: EXCEPTION
291: WHEN NO_DATA_FOUND THEN
292: -- since we involve no sql, this should only happen when there's missing state
293: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_MISSING_STATE;
294: fnd_oam_debug.log(1, l_ctxt, 'Arg ID('||px_arg.arg_id||'), threw missing state.');
295: fnd_oam_debug.log(2, l_ctxt, 'EXIT');
296: RETURN;
297: WHEN OTHERS THEN

Line 331: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN

327:
328: --fetch the value into the properly typed local variable then then
329: --convert it into the canonical
330: CASE px_arg.datatype
331: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN
332: DBMS_SQL.VARIABLE_VALUE(p_execution_cursor_id,
333: l_bindvar_name,
334: x_canonical_value);
335:

Line 336: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN

332: DBMS_SQL.VARIABLE_VALUE(p_execution_cursor_id,
333: l_bindvar_name,
334: x_canonical_value);
335:
336: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN
337: DBMS_SQL.VARIABLE_VALUE(p_execution_cursor_id,
338: l_bindvar_name,
339: l_number);
340: x_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(l_number);

Line 342: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN

338: l_bindvar_name,
339: l_number);
340: x_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(l_number);
341:
342: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN
343: DBMS_SQL.VARIABLE_VALUE(p_execution_cursor_id,
344: l_bindvar_name,
345: l_date);
346: x_canonical_value := FND_DATE.DATE_TO_CANONICAL(l_date);

Line 348: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN

344: l_bindvar_name,
345: l_date);
346: x_canonical_value := FND_DATE.DATE_TO_CANONICAL(l_date);
347:
348: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN
349: DBMS_SQL.VARIABLE_VALUE_ROWID(p_execution_cursor_id,
350: l_bindvar_name,
351: l_rowid);
352: x_canonical_value := ROWIDTOCHAR(l_rowid);

Line 421: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN

417: END IF;
418:
419: --different statements depending on datatype
420: CASE px_arg.datatype
421: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN
422: EXECUTE IMMEDIATE p_final_sql_stmt INTO l_canonical_value;
423: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN
424: EXECUTE IMMEDIATE p_final_sql_stmt INTO l_number;
425: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(l_number);

Line 423: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN

419: --different statements depending on datatype
420: CASE px_arg.datatype
421: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN
422: EXECUTE IMMEDIATE p_final_sql_stmt INTO l_canonical_value;
423: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN
424: EXECUTE IMMEDIATE p_final_sql_stmt INTO l_number;
425: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(l_number);
426: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN
427: EXECUTE IMMEDIATE p_final_sql_stmt INTO l_date;

Line 426: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN

422: EXECUTE IMMEDIATE p_final_sql_stmt INTO l_canonical_value;
423: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN
424: EXECUTE IMMEDIATE p_final_sql_stmt INTO l_number;
425: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(l_number);
426: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN
427: EXECUTE IMMEDIATE p_final_sql_stmt INTO l_date;
428: l_canonical_value := FND_DATE.DATE_TO_CANONICAL(l_date);
429: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN
430: EXECUTE IMMEDIATE p_final_sql_stmt INTO l_rowid;

Line 429: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN

425: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(l_number);
426: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN
427: EXECUTE IMMEDIATE p_final_sql_stmt INTO l_date;
428: l_canonical_value := FND_DATE.DATE_TO_CANONICAL(l_date);
429: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN
430: EXECUTE IMMEDIATE p_final_sql_stmt INTO l_rowid;
431: l_canonical_value := ROWIDTOCHAR(l_rowid);
432: ELSE
433: x_return_msg := 'Arg ID('||px_arg.arg_id||'), invalid datatype: '||px_arg.datatype;

Line 450: FND_OAM_DSCRAM_UTILS_PKG.G_ARG_ROWID_LBOUND_NAME,

446: --bind if we have to
447: IF px_arg.source_sql_bind_rowids THEN
448: fnd_oam_debug.log(1, l_ctxt, 'Binding Rowids');
449: DBMS_SQL.BIND_VARIABLE(px_arg.source_cursor_id,
450: FND_OAM_DSCRAM_UTILS_PKG.G_ARG_ROWID_LBOUND_NAME,
451: p_rowid_lbound);
452: DBMS_SQL.BIND_VARIABLE(px_arg.source_cursor_id,
453: FND_OAM_DSCRAM_UTILS_PKG.G_ARG_ROWID_UBOUND_NAME,
454: p_rowid_ubound);

Line 453: FND_OAM_DSCRAM_UTILS_PKG.G_ARG_ROWID_UBOUND_NAME,

449: DBMS_SQL.BIND_VARIABLE(px_arg.source_cursor_id,
450: FND_OAM_DSCRAM_UTILS_PKG.G_ARG_ROWID_LBOUND_NAME,
451: p_rowid_lbound);
452: DBMS_SQL.BIND_VARIABLE(px_arg.source_cursor_id,
453: FND_OAM_DSCRAM_UTILS_PKG.G_ARG_ROWID_UBOUND_NAME,
454: p_rowid_ubound);
455: END IF;
456:
457: --now execute and fetch

Line 471: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN

467: END IF;
468:
469: --now depending on the datatype, set our local canonical value
470: CASE px_arg.datatype
471: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN
472: DBMS_SQL.COLUMN_VALUE(px_arg.source_cursor_id,
473: 1,
474: l_canonical_value);
475: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN

Line 475: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN

471: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN
472: DBMS_SQL.COLUMN_VALUE(px_arg.source_cursor_id,
473: 1,
474: l_canonical_value);
475: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN
476: DBMS_SQL.COLUMN_VALUE(px_arg.source_cursor_id,
477: 1,
478: l_number);
479: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(l_number);

Line 480: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN

476: DBMS_SQL.COLUMN_VALUE(px_arg.source_cursor_id,
477: 1,
478: l_number);
479: l_canonical_value := FND_NUMBER.NUMBER_TO_CANONICAL(l_number);
480: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN
481: DBMS_SQL.COLUMN_VALUE(px_arg.source_cursor_id,
482: 1,
483: l_date);
484: l_canonical_value := FND_DATE.DATE_TO_CANONICAL(l_date);

Line 485: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN

481: DBMS_SQL.COLUMN_VALUE(px_arg.source_cursor_id,
482: 1,
483: l_date);
484: l_canonical_value := FND_DATE.DATE_TO_CANONICAL(l_date);
485: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN
486: DBMS_SQL.COLUMN_VALUE_ROWID(px_arg.source_cursor_id,
487: 1,
488: l_rowid);
489: l_canonical_value := ROWIDTOCHAR(l_rowid);

Line 509: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_MISSING_BINDS;

505: x_canonical_value := l_canonical_value;
506: fnd_oam_debug.log(2, l_ctxt, 'EXIT');
507: EXCEPTION
508: WHEN missing_binds THEN
509: x_return_status := FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_MISSING_BINDS;
510: fnd_oam_debug.log(1, l_ctxt, 'Arg ID('||px_arg.arg_id||'), threw missing binds.');
511: fnd_oam_debug.log(2, l_ctxt, 'EXIT');
512: RETURN;
513: WHEN OTHERS THEN

Line 551: IF (p_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_SQL_RESTRICTABLE) THEN

547:
548: --SET DERIVED ATTRIBUTES
549:
550: --update the bind_rowids flag based on the source type and whether we're using splitting
551: IF (p_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_SQL_RESTRICTABLE) THEN
552: px_arg.source_sql_bind_rowids := p_use_splitting;
553: END IF;
554:
555: --set the is_constant indicator boolean based on the source_type

Line 556: IF p_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_CONSTANT THEN

552: px_arg.source_sql_bind_rowids := p_use_splitting;
553: END IF;
554:
555: --set the is_constant indicator boolean based on the source_type
556: IF p_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_CONSTANT THEN
557: px_arg.is_constant := TRUE;
558: END IF;
559:
560: --if initialized was already determined, set our value-related state based on inputs

Line 563: IF FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_initialized_success_flag) THEN

559:
560: --if initialized was already determined, set our value-related state based on inputs
561: IF p_initialized_success_flag IS NOT NULL THEN
562: px_arg.initialized_success_flag := p_initialized_success_flag;
563: IF FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_initialized_success_flag) THEN
564: px_arg.valid_value_flag := p_valid_value_flag;
565: IF FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_valid_value_flag) THEN
566: BEGIN
567: SET_STATE_ARG_VALUE(px_arg,

Line 565: IF FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_valid_value_flag) THEN

561: IF p_initialized_success_flag IS NOT NULL THEN
562: px_arg.initialized_success_flag := p_initialized_success_flag;
563: IF FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_initialized_success_flag) THEN
564: px_arg.valid_value_flag := p_valid_value_flag;
565: IF FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(p_valid_value_flag) THEN
566: BEGIN
567: SET_STATE_ARG_VALUE(px_arg,
568: p_canonical_value);
569: EXCEPTION

Line 598: IF p_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_CONSTANT THEN

594: --Since constants are rather common and they dont change, go ahead and validate the value and
595: --store it in the canonical value for quick retrieval later. We don't set the valid_value_flag because
596: --we want get_canonical_value to be able to detect the first time a constant is referenced so it can write it
597: --in the appropriate location.
598: IF p_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_CONSTANT THEN
599:
600: BEGIN
601: VALIDATE_CANONICAL_VALUE(px_arg,
602: p_source_text);

Line 617: ELSIF FND_OAM_DSCRAM_UTILS_PKG.SOURCE_TYPE_USES_SQL(p_source_type) THEN

613:
614: -- The following situations benefit from a source cursor:
615: -- 1) SQL source with write policies of per_range or always
616: -- However, to keep from querying the source_final_text in get_value later, all SQL-based sources use a cursor.
617: ELSIF FND_OAM_DSCRAM_UTILS_PKG.SOURCE_TYPE_USES_SQL(p_source_type) THEN
618:
619: --close the last cursor, shouldn't happen but it's safe
620: IF px_arg.source_cursor_id IS NOT NULL AND DBMS_SQL.IS_OPEN(px_arg.source_cursor_id) THEN
621: DBMS_SQL.CLOSE_CURSOR(px_arg.source_cursor_id);

Line 642: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN

638: END;
639:
640: --finally, define a column with the correct output type
641: CASE px_arg.datatype
642: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN
643: DBMS_SQL.DEFINE_COLUMN(px_arg.source_cursor_id,
644: 1,
645: l_canonical_value,
646: 4000);

Line 647: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN

643: DBMS_SQL.DEFINE_COLUMN(px_arg.source_cursor_id,
644: 1,
645: l_canonical_value,
646: 4000);
647: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN
648: DBMS_SQL.DEFINE_COLUMN(px_arg.source_cursor_id,
649: 1,
650: l_number);
651: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN

Line 651: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN

647: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN
648: DBMS_SQL.DEFINE_COLUMN(px_arg.source_cursor_id,
649: 1,
650: l_number);
651: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN
652: DBMS_SQL.DEFINE_COLUMN(px_arg.source_cursor_id,
653: 1,
654: l_date);
655: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN

Line 655: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN

651: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN
652: DBMS_SQL.DEFINE_COLUMN(px_arg.source_cursor_id,
653: 1,
654: l_date);
655: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN
656: DBMS_SQL.DEFINE_COLUMN_ROWID(px_arg.source_cursor_id,
657: 1,
658: l_rowid);
659: ELSE

Line 669: ELSIF p_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_STATE THEN

665: END CASE;
666:
667: --set these sorts of args to be initialized
668: px_arg.initialized_success_flag := FND_API.G_TRUE;
669: ELSIF p_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_STATE THEN
670: --set the source state key using the first 30 chars of the source_text
671: px_arg.source_state_key := SUBSTR(p_source_text, 1, 30);
672: px_arg.initialized_success_flag := FND_API.G_TRUE;
673: ELSIF p_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_EXECUTION_CURSOR THEN

Line 673: ELSIF p_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_EXECUTION_CURSOR THEN

669: ELSIF p_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_STATE THEN
670: --set the source state key using the first 30 chars of the source_text
671: px_arg.source_state_key := SUBSTR(p_source_text, 1, 30);
672: px_arg.initialized_success_flag := FND_API.G_TRUE;
673: ELSIF p_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_EXECUTION_CURSOR THEN
674: --set the use_exec_cursor indicator variable for the arg
675: px_arg.source_use_exec_cursor := TRUE;
676: px_arg.initialized_success_flag := FND_API.G_TRUE;
677: ELSIF p_source_type IS NULL THEN

Line 724: fnd_oam_debug.log(1, l_ctxt, 'Argument(Splitting?): '||px_arg.arg_name||'('||FND_OAM_DSCRAM_UTILS_PKG.BOOLEAN_TO_FLAG(p_using_splitting)||')');

720: fnd_oam_debug.log(2, l_ctxt, 'ENTER');
721: x_return_status := FND_API.G_RET_STS_ERROR;
722: x_return_msg := '';
723:
724: fnd_oam_debug.log(1, l_ctxt, 'Argument(Splitting?): '||px_arg.arg_name||'('||FND_OAM_DSCRAM_UTILS_PKG.BOOLEAN_TO_FLAG(p_using_splitting)||')');
725:
726: --check if we've already done the local init
727: IF px_arg.init_locally THEN
728: x_return_status := FND_API.G_RET_STS_SUCCESS;

Line 786: IF FND_OAM_DSCRAM_UTILS_PKG.SOURCE_TYPE_USES_SQL(l_source_type) THEN

782: --at this point it's up to this function to do the init, reset the valid value flag to unknown
783: l_valid_value_flag := NULL;
784:
785: --for sqls, compose our final source statement from its component parts
786: IF FND_OAM_DSCRAM_UTILS_PKG.SOURCE_TYPE_USES_SQL(l_source_type) THEN
787:
788: --see whether we'll be appending the rowid clause or not
789: l_append_rowid_clause := FALSE;
790: IF l_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_SQL_RESTRICTABLE THEN

Line 790: IF l_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_SQL_RESTRICTABLE THEN

786: IF FND_OAM_DSCRAM_UTILS_PKG.SOURCE_TYPE_USES_SQL(l_source_type) THEN
787:
788: --see whether we'll be appending the rowid clause or not
789: l_append_rowid_clause := FALSE;
790: IF l_source_type = FND_OAM_DSCRAM_UTILS_PKG.G_SOURCE_SQL_RESTRICTABLE THEN
791: l_append_rowid_clause := p_using_splitting;
792: END IF;
793:
794: --prepare the final text from the source_text/where clause

Line 795: FND_OAM_DSCRAM_UTILS_PKG.MAKE_FINAL_SQL_STMT(p_arg_context,

791: l_append_rowid_clause := p_using_splitting;
792: END IF;
793:
794: --prepare the final text from the source_text/where clause
795: FND_OAM_DSCRAM_UTILS_PKG.MAKE_FINAL_SQL_STMT(p_arg_context,
796: l_source_text,
797: l_source_where_clause,
798: l_append_rowid_clause,
799: l_source_final_text,

Line 953: IF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE THEN

949: fnd_oam_debug.log(2, l_ctxt, 'ENTER');
950: x_return_status := FND_API.G_RET_STS_ERROR;
951: x_return_msg := '';
952:
953: IF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE THEN
954: --update the main args_b row
955: UPDATE fnd_oam_dscram_args_b
956: SET valid_value_flag = px_arg.valid_value_flag,
957: canonical_value = px_arg.canonical_value,

Line 962: ELSIF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_WORKER THEN

958: last_updated_by = fnd_global.user_id,
959: last_update_login = fnd_global.user_id,
960: last_update_date = SYSDATE
961: WHERE arg_id = px_arg.arg_id;
962: ELSIF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_WORKER THEN
963: --try to update arg_values with parent_type=worker, failing that insert
964: UPDATE fnd_oam_dscram_arg_values
965: SET valid_value_flag = px_arg.valid_value_flag,
966: canonical_value = px_arg.canonical_value,

Line 971: AND parent_type = FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_WORKER AND

967: last_updated_by = fnd_global.user_id,
968: last_update_login = fnd_global.user_id,
969: last_update_date = SYSDATE
970: WHERE arg_id = px_arg.arg_id
971: AND parent_type = FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_WORKER AND
972: parent_id = FND_OAM_DSCRAM_BUNDLES_PKG.GET_WORKER_ID;
973: IF SQL%ROWCOUNT = 0 THEN
974: fnd_oam_debug.log(1, l_ctxt, 'Inserting per-worker arg value.');
975: INSERT_ARG_VALUE(px_arg.arg_id,

Line 978: FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_WORKER,

974: fnd_oam_debug.log(1, l_ctxt, 'Inserting per-worker arg value.');
975: INSERT_ARG_VALUE(px_arg.arg_id,
976: px_arg.valid_value_flag,
977: px_arg.canonical_value,
978: FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_WORKER,
979: FND_OAM_DSCRAM_BUNDLES_PKG.GET_WORKER_ID,
980: x_arg_val_id => l_arg_val_id);
981: END IF;
982: ELSIF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_RANGE THEN

Line 982: ELSIF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_RANGE THEN

978: FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_WORKER,
979: FND_OAM_DSCRAM_BUNDLES_PKG.GET_WORKER_ID,
980: x_arg_val_id => l_arg_val_id);
981: END IF;
982: ELSIF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_RANGE THEN
983: --update arg_values with range values and parent_type = range
984: UPDATE fnd_oam_dscram_arg_values
985: SET valid_value_flag = px_arg.valid_value_flag,
986: canonical_value = px_arg.canonical_value,

Line 993: parent_type = FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_RANGE AND

989: last_updated_by = fnd_global.user_id,
990: last_update_login = fnd_global.user_id,
991: last_update_date = SYSDATE
992: WHERE arg_id = px_arg.arg_id AND
993: parent_type = FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_RANGE AND
994: rowid_lbound = px_arg.rowid_lbound AND
995: rowid_ubound = px_arg.rowid_ubound;
996: IF SQL%ROWCOUNT = 0 THEN
997: fnd_oam_debug.log(1, l_ctxt, 'Inserting per-range arg value.');

Line 1001: FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_RANGE,

997: fnd_oam_debug.log(1, l_ctxt, 'Inserting per-range arg value.');
998: INSERT_ARG_VALUE(px_arg.arg_id,
999: px_arg.valid_value_flag,
1000: px_arg.canonical_value,
1001: FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_RANGE,
1002: p_rowid_lbound => px_arg.rowid_lbound,
1003: p_rowid_ubound => px_arg.rowid_ubound,
1004: x_arg_val_id => l_arg_val_id);
1005: END IF;

Line 1006: ELSIF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ALWAYS THEN

1002: p_rowid_lbound => px_arg.rowid_lbound,
1003: p_rowid_ubound => px_arg.rowid_ubound,
1004: x_arg_val_id => l_arg_val_id);
1005: END IF;
1006: ELSIF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ALWAYS THEN
1007: fnd_oam_debug.log(1, l_ctxt, 'Inserting always arg value.');
1008: INSERT_ARG_VALUE(px_arg.arg_id,
1009: px_arg.valid_value_flag,
1010: px_arg.canonical_value,

Line 1140: NOT (px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ALWAYS)) THEN

1136: RETURN;
1137: -- see if we already have a value, skip the check if we write always
1138: ELSIF px_arg.valid_value_flag = FND_API.G_TRUE AND
1139: (NOT (IS_WRITABLE(px_arg)) OR
1140: NOT (px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ALWAYS)) THEN
1141: --if we already know the local value is valid then make sure we match the supplied rowid range as well
1142: IF (px_arg.rowid_lbound IS NOT NULL OR px_arg.rowid_ubound IS NOT NULL) THEN
1143: IF ((px_arg.rowid_lbound IS NULL OR (px_arg.rowid_lbound = p_rowid_lbound)) AND
1144: (px_arg.rowid_ubound IS NULL OR (px_arg.rowid_ubound = p_rowid_ubound))) THEN

Line 1164: IF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE THEN

1160: ELSE
1161: -- we haven't cached that the value's valid somewhere, but it may have been calculated and stored already in the DB
1162: -- use different select statements to find the latest valid_value_flag and canonical_value
1163: l_valid_value_flag := NULL;
1164: IF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE THEN
1165: --query the main args_b row
1166: SELECT valid_value_flag, canonical_value
1167: INTO l_valid_value_flag, l_canonical_value
1168: FROM fnd_oam_dscram_args_b

Line 1171: ELSIF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_WORKER THEN

1167: INTO l_valid_value_flag, l_canonical_value
1168: FROM fnd_oam_dscram_args_b
1169: WHERE arg_id = px_arg.arg_id;
1170: fnd_oam_debug.log(1, l_ctxt, 'Write Policy Once: first query valid_value_flag: '||l_valid_value_flag);
1171: ELSIF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_WORKER THEN
1172: --Needed in the case of restart to get the value we may have comitted for this worker
1173: --query arg_values with parent_type=worker
1174: BEGIN
1175: SELECT valid_value_flag, canonical_value

Line 1179: parent_type = FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_WORKER AND

1175: SELECT valid_value_flag, canonical_value
1176: INTO l_valid_value_flag, l_canonical_value
1177: FROM fnd_oam_dscram_arg_values
1178: WHERE arg_id = px_arg.arg_id AND
1179: parent_type = FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_WORKER AND
1180: parent_id = FND_OAM_DSCRAM_BUNDLES_PKG.GET_WORKER_ID;
1181: EXCEPTION
1182: WHEN OTHERS THEN
1183: l_valid_value_flag := NULL;

Line 1186: ELSIF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_RANGE THEN

1182: WHEN OTHERS THEN
1183: l_valid_value_flag := NULL;
1184: END;
1185: fnd_oam_debug.log(1, l_ctxt, 'Write Policy Per-Worker: first query valid_value_flag: '||l_valid_value_flag);
1186: ELSIF px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_RANGE THEN
1187: --Since we don't share ranges, this won't happen on the initial execute, but it may be necessary on restart
1188: --if the arg's value was comitted since we won't read it back on initialize.
1189: --query arg_values with range values and parent_type = range
1190: BEGIN

Line 1195: parent_type = FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_RANGE AND

1191: SELECT valid_value_flag, canonical_value
1192: INTO l_valid_value_flag, l_canonical_value
1193: FROM fnd_oam_dscram_arg_values
1194: WHERE arg_id = px_arg.arg_id AND
1195: parent_type = FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_RANGE AND
1196: rowid_lbound = p_rowid_lbound AND
1197: rowid_ubound = p_rowid_ubound;
1198: EXCEPTION
1199: WHEN OTHERS THEN

Line 1220: px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE THEN

1216:
1217: --for write_once, we need to lock the arg and check again, the rest don't need a lock because there's no cross-worker contention.
1218: IF NOT l_determined_value AND
1219: IS_WRITABLE(px_arg) AND
1220: px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE THEN
1221:
1222: --lock the arg
1223: IF FND_OAM_DSCRAM_UTILS_PKG.LOCK_ARG(px_arg.arg_id,
1224: l_lock_handle) THEN

Line 1223: IF FND_OAM_DSCRAM_UTILS_PKG.LOCK_ARG(px_arg.arg_id,

1219: IS_WRITABLE(px_arg) AND
1220: px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE THEN
1221:
1222: --lock the arg
1223: IF FND_OAM_DSCRAM_UTILS_PKG.LOCK_ARG(px_arg.arg_id,
1224: l_lock_handle) THEN
1225: --do a normal select instead of a locking select since the above lock will hold for write_once args even if release_lock
1226: --is set when a worker is the first to determine a value for the arg. The lock will be released when the first worker
1227: --to set the arg commits or rolls back.

Line 1313: ELSIF l_return_status = FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_MISSING_STATE THEN

1309: l_valid_value_flag := FND_API.G_FALSE;
1310: END;
1311: l_determined_value := TRUE;
1312: l_value_requires_store := TRUE;
1313: ELSIF l_return_status = FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_MISSING_STATE THEN
1314: -- if we didn't fail as much as we were called under the wrong circumstances, don't store this as a failure either
1315: x_return_status := l_return_status;
1316: x_return_msg := l_return_msg;
1317: RAISE GET_FAILED;

Line 1368: ELSIF l_return_status = FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_MISSING_BINDS THEN

1364: l_valid_value_flag := FND_API.G_FALSE;
1365: END;
1366: l_determined_value := TRUE;
1367: l_value_requires_store := TRUE;
1368: ELSIF l_return_status = FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_MISSING_BINDS THEN
1369: -- if we didn't fail as much as we were called under the wrong circumstances, don't store this as a failure either
1370: x_return_status := l_return_status;
1371: x_return_msg := l_return_msg;
1372: RAISE GET_FAILED;

Line 1407: ELSIF l_return_status = FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_MISSING_BINDS THEN

1403: IF l_return_status = FND_API.G_RET_STS_SUCCESS THEN
1404: l_valid_value_flag := FND_API.G_TRUE;
1405: l_determined_value := TRUE;
1406: l_value_requires_store := TRUE;
1407: ELSIF l_return_status = FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_MISSING_BINDS THEN
1408: --since this is the last thing before failure, let missing binds return
1409: x_return_status := l_return_status;
1410: x_return_msg := l_return_msg;
1411: fnd_oam_debug.log(1, l_ctxt, 'Returning Missing Binds');

Line 1428: IF FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(l_valid_value_flag) THEN

1424:
1425: -- if we found a value, sync up the value state with the get even if we're not going to write it out
1426: IF l_determined_value THEN
1427: px_arg.valid_value_flag := l_valid_value_flag;
1428: IF FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(l_valid_value_flag) THEN
1429: px_arg.canonical_value := l_canonical_value;
1430: ELSE
1431: px_arg.canonical_value := NULL;
1432: END IF;

Line 1435: IF l_determined_value AND px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_RANGE THEN

1431: px_arg.canonical_value := NULL;
1432: END IF;
1433:
1434: --if we determined a value and we're fetching values for each range, store the range used.
1435: IF l_determined_value AND px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_RANGE THEN
1436: px_arg.rowid_lbound := p_rowid_lbound;
1437: px_arg.rowid_ubound := p_rowid_ubound;
1438: END IF;
1439: END IF;

Line 1467: ((px_arg.write_policy <> FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE) OR

1463: --release the lock on the arg if told to do so and the arg isn't a just-stored write-once value.
1464: --Just-written, write-once args hold onto the lock until the batch is comitted or rolled back so that other
1465: --workers don't compute a new value. These args are treated as possible synchronization points.
1466: IF p_release_arg_lock AND
1467: ((px_arg.write_policy <> FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE) OR
1468: (px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE AND NOT l_value_requires_store)) THEN
1469: IF l_lock_handle IS NOT NULL THEN
1470: l_retval := DBMS_LOCK.RELEASE(l_lock_handle);
1471: IF l_retval <> 0 THEN

Line 1468: (px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE AND NOT l_value_requires_store)) THEN

1464: --Just-written, write-once args hold onto the lock until the batch is comitted or rolled back so that other
1465: --workers don't compute a new value. These args are treated as possible synchronization points.
1466: IF p_release_arg_lock AND
1467: ((px_arg.write_policy <> FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE) OR
1468: (px_arg.write_policy = FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE AND NOT l_value_requires_store)) THEN
1469: IF l_lock_handle IS NOT NULL THEN
1470: l_retval := DBMS_LOCK.RELEASE(l_lock_handle);
1471: IF l_retval <> 0 THEN
1472: fnd_oam_debug.log(6, l_ctxt, 'Failed to release arg lock: '||l_retval);

Line 1481: IF FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(l_valid_value_flag) THEN

1477: x_arg_lock_handle := l_lock_handle;
1478: END IF;
1479:
1480: --done, change return status based on whether we found a valid value even if we didn't store it
1481: IF FND_OAM_DSCRAM_UTILS_PKG.FLAG_TO_BOOLEAN(l_valid_value_flag) THEN
1482: x_return_status := FND_API.G_RET_STS_SUCCESS;
1483: x_value := l_canonical_value;
1484: ELSIF (NOT p_allow_sourcing AND l_valid_value_flag IS NULL) THEN
1485: --return success if something which was unallowed to source ended up without a value, since we're only

Line 1878: FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_MISSING_BINDS) THEN

1874: END IF;
1875:
1876: --fail if the context arg was not failed sucessfully, ignore missing bind cases
1877: IF l_return_status NOT IN (FND_API.G_RET_STS_SUCCESS,
1878: FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_MISSING_BINDS) THEN
1879: x_return_status := l_return_status;
1880: x_return_msg := l_return_msg;
1881: fnd_oam_debug.log(2, l_ctxt, 'EXIT');
1882: ROLLBACK;

Line 2003: WHERE ((parent_type = FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_GLOBAL) OR

1999: SELECT arg_id, arg_name, initialized_success_flag, allow_override_source_flag, binding_enabled_flag, permissions, write_policy, datatype, valid_value_flag, canonical_value
2000: BULK COLLECT INTO l_arg_ids, l_arg_names, l_initialized_success_flags, l_allow_override_source_flags, l_binding_enabled_flags, l_permissions,
2001: l_write_policies, l_datatypes, l_valid_value_flags, l_canonical_values
2002: FROM fnd_oam_dscram_args_b
2003: WHERE ((parent_type = FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_GLOBAL) OR
2004: ((parent_type = FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_RUN) AND
2005: (parent_id = p_run_id)))
2006: AND enabled_flag = FND_API.G_TRUE
2007: ORDER BY parent_type ASC;

Line 2004: ((parent_type = FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_RUN) AND

2000: BULK COLLECT INTO l_arg_ids, l_arg_names, l_initialized_success_flags, l_allow_override_source_flags, l_binding_enabled_flags, l_permissions,
2001: l_write_policies, l_datatypes, l_valid_value_flags, l_canonical_values
2002: FROM fnd_oam_dscram_args_b
2003: WHERE ((parent_type = FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_GLOBAL) OR
2004: ((parent_type = FND_OAM_DSCRAM_UTILS_PKG.G_TYPE_RUN) AND
2005: (parent_id = p_run_id)))
2006: AND enabled_flag = FND_API.G_TRUE
2007: ORDER BY parent_type ASC;
2008:

Line 2027: IF FND_OAM_DSCRAM_UTILS_PKG.RUN_IS_DIAGNOSTIC THEN

2023:
2024: k := l_arg_ids.NEXT(k);
2025: END LOOP;
2026:
2027: IF FND_OAM_DSCRAM_UTILS_PKG.RUN_IS_DIAGNOSTIC THEN
2028: --print the arg context and allow failures here to indicate an overall failure so
2029: --a diagnostic test can detect it
2030: internal_print_arg_context(l_arg_ctxt,
2031: TRUE,

Line 2139: IF FND_OAM_DSCRAM_UTILS_PKG.RUN_IS_DIAGNOSTIC THEN

2135: k := l_arg_ids.NEXT(k);
2136: END LOOP;
2137:
2138: --debug
2139: IF FND_OAM_DSCRAM_UTILS_PKG.RUN_IS_DIAGNOSTIC THEN
2140: --print the arg list and allow failures here to indicate an overall failure so
2141: --a diagnostic test can detect it. We don't get the values for args because it screws up
2142: --operations too much and bind_args will get them all when the time is right anyway.
2143: print_arg_list(l_arg_list,

Line 2220: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN

2216:
2217: --first do the fetch if its readable
2218: IF IS_READABLE(p_arg_list(k)) THEN
2219: CASE p_arg_list(k).datatype
2220: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN
2221: --fetch
2222: GET_ARG_VALUE(p_arg_list(k),
2223: px_arg_context,
2224: p_using_splitting,

Line 2240: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN

2236: fnd_oam_debug.log(2, l_ctxt, 'EXIT');
2237: RETURN;
2238: END IF;
2239:
2240: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN
2241: --fetch
2242: GET_ARG_VALUE(p_arg_list(k),
2243: px_arg_context,
2244: p_using_splitting,

Line 2261: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN

2257: fnd_oam_debug.log(2, l_ctxt, 'EXIT');
2258: RETURN;
2259: END IF;
2260:
2261: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN
2262: --fetch
2263: GET_ARG_VALUE(p_arg_list(k),
2264: px_arg_context,
2265: p_using_splitting,

Line 2282: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN

2278: fnd_oam_debug.log(2, l_ctxt, 'EXIT');
2279: RETURN;
2280: END IF;
2281:
2282: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN
2283: --fetch
2284: GET_ARG_VALUE_ROWID(p_arg_list(k),
2285: px_arg_context,
2286: p_using_splitting,

Line 2313: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN

2309:
2310: --even if we didn't get a value, do a binding - required for output args.
2311: BEGIN
2312: CASE p_arg_list(k).datatype
2313: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_VARCHAR2 THEN
2314: DBMS_SQL.BIND_VARIABLE(p_cursor_id,
2315: l_bindvar_name,
2316: l_varchar2,
2317: 4000);

Line 2319: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN

2315: l_bindvar_name,
2316: l_varchar2,
2317: 4000);
2318:
2319: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_NUMBER THEN
2320: DBMS_SQL.BIND_VARIABLE(p_cursor_id,
2321: l_bindvar_name,
2322: l_number);
2323:

Line 2324: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN

2320: DBMS_SQL.BIND_VARIABLE(p_cursor_id,
2321: l_bindvar_name,
2322: l_number);
2323:
2324: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_DATE THEN
2325: DBMS_SQL.BIND_VARIABLE(p_cursor_id,
2326: l_bindvar_name,
2327: l_date);
2328:

Line 2329: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN

2325: DBMS_SQL.BIND_VARIABLE(p_cursor_id,
2326: l_bindvar_name,
2327: l_date);
2328:
2329: WHEN FND_OAM_DSCRAM_UTILS_PKG.G_DATATYPE_ROWID THEN
2330: DBMS_SQL.BIND_VARIABLE_ROWID(p_cursor_id,
2331: l_bindvar_name,
2332: l_rowid);
2333: ELSE

Line 2393: IF NOT FND_OAM_DSCRAM_UTILS_PKG.RUN_IS_NORMAL THEN

2389: x_return_msg := '';
2390:
2391: --if we're in a non-normal mode, store the values we get autonomously to keep them from
2392: --getting rolled back
2393: IF NOT FND_OAM_DSCRAM_UTILS_PKG.RUN_IS_NORMAL THEN
2394: l_force_store_autonomously := TRUE;
2395: END IF;
2396:
2397: --loop through the arg list

Line 2409: (px_arg_list(k).write_policy IN (FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE,

2405: --executed until the arg is finished and execute PER_RANGE/ALWAYS when not finished or
2406: --we're finished and not using splitting.
2407: IF ((p_entity_finished AND
2408: (NOT p_using_splitting OR
2409: (px_arg_list(k).write_policy IN (FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE,
2410: FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_WORKER)))) OR
2411: (NOT p_entity_finished AND
2412: (px_arg_list(k).write_policy IN (FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_RANGE,
2413: FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ALWAYS)))) THEN

Line 2410: FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_WORKER)))) OR

2406: --we're finished and not using splitting.
2407: IF ((p_entity_finished AND
2408: (NOT p_using_splitting OR
2409: (px_arg_list(k).write_policy IN (FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE,
2410: FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_WORKER)))) OR
2411: (NOT p_entity_finished AND
2412: (px_arg_list(k).write_policy IN (FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_RANGE,
2413: FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ALWAYS)))) THEN
2414:

Line 2412: (px_arg_list(k).write_policy IN (FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_RANGE,

2408: (NOT p_using_splitting OR
2409: (px_arg_list(k).write_policy IN (FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE,
2410: FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_WORKER)))) OR
2411: (NOT p_entity_finished AND
2412: (px_arg_list(k).write_policy IN (FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_RANGE,
2413: FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ALWAYS)))) THEN
2414:
2415: GET_CANONICAL_ARG_VALUE(px_arg_list(k),
2416: px_arg_context,

Line 2413: FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ALWAYS)))) THEN

2409: (px_arg_list(k).write_policy IN (FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ONCE,
2410: FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_WORKER)))) OR
2411: (NOT p_entity_finished AND
2412: (px_arg_list(k).write_policy IN (FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_PER_RANGE,
2413: FND_OAM_DSCRAM_UTILS_PKG.G_WRITE_POLICY_ALWAYS)))) THEN
2414:
2415: GET_CANONICAL_ARG_VALUE(px_arg_list(k),
2416: px_arg_context,
2417: p_using_splitting,

Line 2429: l_return_status <> FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_MISSING_BINDS THEN

2425: l_canonical_value,
2426: l_return_status,
2427: l_return_msg);
2428: IF l_return_status <> FND_API.G_RET_STS_SUCCESS AND
2429: l_return_status <> FND_OAM_DSCRAM_UTILS_PKG.G_RET_STS_MISSING_BINDS THEN
2430:
2431: --if an arg failed to get a value, return it as an error, stop fetching other args
2432: x_return_status := l_return_status;
2433: x_return_msg := l_return_msg;