OCI-22303: type ""."DISCREPTABTYP"

Question

OCI-22303: type ""."DISCREPTABTYP" not found:BEGIN
timeKeeper_package.discrepancy2(:unit, :startdate, :enddate, :unknown_tb, :belongWork_tb, :floatIn_tb, :floatOut_tb);
END;
I am getting the above error when I am running at OCI program through a web application. This did work on another server 2 years ago. Project got put on hold and now that DB on that server can be restarted, I need to install in on a new server and db. I created this type for a user and granted permissions to public. I think it is either some sort of permission problem or patch problem. When I orginally worked on project it was in oracle 9i and one of last things I did was upgrade db to 11g. I don't know if I had to make some sort of change when I did that upgrade. But I need to get it working again on a 9i database (9.2.0.3.0)
Below I have include 3 parts that I think make up the the problem
1) The oci code that is giving error message
2) The sql that creates the type
3) The package that the OCI program is trying to run ( i had to remove comments for max length in oracle forums)
So I am looking for help on what I might be missing or re createing this application. I kind of think I may have had to do something different with creating the type. For all of the .sql I just ran them as same user that owns all of my other tables.
1) Below is line from OCI program that is failing
if (ociCheckError("timeDiscrepancy.c(8008)", OCITypeByName(hba.envhp, hba.errhp, hba.svchp,
(text *) 0, (ub4) 0, (text *) "DISCREPTABTYP", (ub4) strlen((const char *) "DISCREPTABTYP"),
(CONST text *) 0, (ub4) 0, OCI_DURATION_SESSION, OCI_TYPEGET_HEADER,
&discreptab_tdo), TRUE, &hba) == -1) {
callMessage(&hba);
deconstructHba(&hba);
return (0);
2) Below is sql that crated type
drop type discrepTabTyp;
Create or Replace Type discrepancyType as object(
empcd varchar2(12),
skilltpe varchar2(9),
hprdcode varchar2(6),
wprdcode varchar2(6),
strtdate date,
enddate date,
empupdate date,
empfnme varchar2(12),
empmint varchar2(2),
emplnme varchar2(20),
prodcode varchar2(6),
startscan date,
endscan date,
origstart date,
reason varchar2(23),
timeupdate date)
GRANT EXECUTE ON DISCREPANCYTYPE TO public;
CREATE PUBLIC SYNONYM DISCREPANCYTYPE FOR DISCREPANCYTYPE;
Create or Replace type discrepTabTyp is table of discrepancyType
GRANT EXECUTE ON DISCREPTABTYP TO public;
CREATE PUBLIC SYNONYM DISCREPTABTYP FOR DISCREPTABTYP;
3) Below is the package that the OCI program is trying to run
create or replace package timeKeeper_package as
Type empschdRec IS RECORD (
hprdcode empschd.hprdcode%type,
empcd empschd.empcode%type,
skilltpe empschd.skilltpe%type,
wprdcode empschd.wprdcode%type,
strtdate date,
enddate date,
lastupdate date,
match pls_integer);
Type timeRec IS RECORD (
prodcode time_keeper.prodcode%type,
empcd time_keeper.empcode%type,
origstart date,
startscan date,
endscan date,
lastupdate date,
match pls_integer);
Type discrepancyRec IS RECORD (
empcd empschd.empcode%type DEFAULT '',
skilltpe empschd.skilltpe%type DEFAULT'',
hprdcode empschd.hprdcode%type DEFAULT '',
wprdcode empschd.wprdcode%type DEFAULT '',
strtdate date DEFAULT NULL,
enddate date DEFAULT NULL,
empupdate date DEFAULT NULL,
empfnme empcode.empfnme%type DEFAULT ' ',
empmint empcode.empmint%type DEFAULT ' ',
emplnme empcode.emplnme%type DEFAULT ' ',
prodcode time_keeper.prodcode%type DEFAULT '',
startscan date DEFAULT NULL,
endscan date DEFAULT NULL,
origstart date DEFAULT NULL,
timeupdate date DEFAULT NULL,
reason varchar2(23) DEFAULT '');
type empArray is table of empschdRec index by pls_integer;
type timeArray is table of timeRec index by pls_integer;
type discrepancyArray is table of discrepancyRec index by pls_integer;
procedure discrepancy (unit in prodcode.prodcode%type, start_date date, end_date date,
unknown_tb in out discrepancyArray, belongWork_tb in out discrepancyArray,
floatIn_tb in out discrepancyArray, floatOut_tb in out discrepancyArray);
procedure discrepancy2 (unit in prodcode.prodcode%type,
start_date date, end_date date,
unknown_tab out discrepTabTyp, belongWork_tab out discrepTabTyp,
floatIn_tab out discrepTabTyp, floatOut_tab out discrepTabTyp);
procedure match (unit in prodcode.prodcode%type, start_date date, end_date date,
empschd_tb out empArray, time_keeper_tb out timeArray);
end timeKeeper_package;
create or replace package body timeKeeper_package as
Type empcodeRec IS RECORD (
prodcode empcode.prodcode%type,
empcd empcode.empcode%type,
bskiltpe empcode.bskiltpe%type,
empfnme empcode.empfnme%type,
empmint empcode.empmint%type,
emplnme empcode.emplnme%type,
swipe empcode.swipe%type,
home_swipe empcode.home_swipe%type);
type empcodeArray is table of empcodeRec index by pls_integer;
function empcode_find (empcd empcode.empcode%type, emcdTable empcodeArray,
maxIndex int) return int;
procedure add_discrepancy (unit in prodcode.prodcode%type,
unknown_tb in out discrepancyArray,
belongWork_tb in out discrepancyArray,floatIn_tb in out discrepancyArray,
floatOut_tb in out discrepancyArray,
empcode_tb empcodeArray, empcdIndex pls_integer,
empschd_tb empArray,schdIndex pls_integer,
time_keeper_tb timeArray, timeIndex pls_integer, reason varchar2);
procedure match (unit in prodcode.prodcode%type, start_date date, end_date date,
empschd_tb out empArray, time_keeper_tb out timeArray) as
CURSOR schd_cursor is
select empschd.hprdcode,empschd.empcode,empschd.skilltpe,empschd.wprdcode,
empschd.strtdate,empschd.enddate, empschd.lastupdate, 0
from empschd,empcode
where (empschd.hprdcode = unit or empschd.wprdcode = unit) and
(empschd.strtdate between start_date and end_date or
empschd.enddate between start_date and end_date)
and empschd.openclsd = 'OPEN' and empcode.empcode = empschd.empcode and
empcode.swipe = 'Y' and empcode.termcode is null
order by empschd.empcode,empschd.strtdate,empschd.enddate;
CURSOR time_cursor is
select time_keeper.prodcode, time_keeper.empcode, time_keeper.origstart,
time_keeper.startscan, time_keeper.endscan, time_keeper.lastupdate, 0
from time_keeper, prodcode
where (time_keeper.empcode in (select empcode from empcode where prodcode = unit)
or time_keeper.prodcode = unit) and
(time_keeper.startscan between (start_date - (prodcode.scan_reset/24))
and (end_date + (prodcode.scan_reset/24)) or
time_keeper.endscan between (start_date - (prodcode.scan_reset/24))
and (end_date + (prodcode.scan_reset/24))) and
time_keeper.active = 'Y' and prodcode.prodcode = unit
order by time_keeper.empcode, time_keeper.startscan, time_keeper.endscan;
timeIndex integer; -- current index in time_keeper_tb
diffCurrent float; -- difference between current empschd and time keeper start dates
diffNext float; -- difference between current empschd and next time keeper start dates
diffEmp2 float; -- difference between next empschd 7 current time keeper start dates
BEGIN
open schd_cursor;
fetch schd_cursor bulk collect into empschd_tb;
close schd_cursor;
open time_cursor;
fetch time_cursor bulk collect into time_keeper_tb;
close time_cursor;
if (empschd_tb.FIRST is not NULL and time_keeper_tb.FIRST is not NULL) then
timeIndex := 1;
for i in empschd_tb.FIRST .. empschd_tb.LAST
loop
while (timeIndex <= time_keeper_tb.LAST and (time_keeper_tb(timeIndex).match != 0 or
time_keeper_tb(timeIndex).empcd != empschd_tb(i).empcd))
loop
timeIndex := timeIndex + 1;
end loop;
if (timeIndex > time_keeper_tb.LAST) then
timeIndex := 1;
else
diffCurrent := abs (empschd_tb(i).strtdate - time_keeper_tb(timeIndex).startscan);
while (timeIndex < time_keeper_tb.LAST and
time_keeper_tb(timeIndex).empcd = empschd_tb(i).empcd)
loop
if (timeIndex+1 <= time_keeper_tb.LAST and
empschd_tb(i).empcd = time_keeper_tb(timeIndex+1).empcd) then
diffNext := abs (empschd_tb(i).strtdate - time_keeper_tb(timeIndex+1).startscan);
else
diffNext := diffCurrent;
end if;
exit when diffCurrent <= diffNext;
timeIndex := timeIndex + 1;
diffCurrent := diffNext;
end loop; -- end while finding closesest empschd
if (i+1 <= empschd_tb.LAST and
empschd_tb(i+1).empcd = time_keeper_tb(timeIndex).empcd) then
diffEmp2 := abs (empschd_tb(i+1).strtdate - time_keeper_tb(timeIndex).startscan);
else
diffEmp2 := diffCurrent;
end if;
-- decide which time keeper record to match to current empschd record
if (diffCurrent <= diffEmp2) then
empschd_tb(i).match := timeIndex;
time_keeper_tb(timeIndex).match := i;
timeIndex := timeIndex+1;
else
-- if previous time_keeper record is unmatched,
-- then match it to current empschd else it remains unmatched
if (timeIndex > 1 and time_keeper_tb(timeIndex-1).match = 0 and
empschd_tb(i).empcd = time_keeper_tb(timeIndex-1).empcd) then
empschd_tb(i).match := timeIndex-1;
time_keeper_tb(timeIndex-1).match := i;
end if;
end if; -- end else next empschd was closer
end if;
end loop; -- end for each empschd
end if;
-- utl_file.fclose (fip);
END match;
procedure discrepancy (unit in prodcode.prodcode%type,
start_date date, end_date date,
unknown_tb in out discrepancyArray, belongWork_tb in out discrepancyArray,
floatIn_tb in out discrepancyArray, floatOut_tb in out discrepancyArray) as
-- read in all non terminated employee records
CURSOR emp_cursor is
select prodcode, empcode, bskiltpe, empfnme, nvl(empmint,' '), emplnme,
swipe, home_swipe
from empcode
where termcode is null
order by empcode;
empcode_tb empcodeArray; -- holds non terminated employee array
employee_index pls_integer; -- current employee in empcode_tb
timeKeeper_indx pls_integer; -- current time keeper record
empschd_tb empArray; -- holds employee schedule data
time_keeper_tb timeArray; -- holds time keeper data
unitgrace number (38,34); -- unit's grace time
found boolean; -- indicates if discrepancy found
reason varchar2(23); -- the reason of discrepancy
fip utl_file.file_type;
begin
-- this places record in all_directories table which seems to be used by fopen
fip := utl_file.fopen ('TIME_KEEP_DIR','discrepancy.pr','w',500);
-- read and convert grace time for unit from minutes to fraction
-- of 1 day for date comparisons
select (grace_time / 60)/24
into unitgrace
from prodcode where prodcode = unit;
-- get the employee records to validate employee codes scanned
open emp_cursor;
fetch emp_cursor bulk collect into empcode_tb;
close emp_cursor;
utl_file.put_line(fip, 'match start '|| to_char (start_date, 'MM/DD/YYYY HH:MI:SS AM') ||
' End: ' || to_char (end_date, 'MM/DD/YYYY HH:MI:SS AM'), TRUE);
-- given a unit, start time and end time, read in and match employee schedule
-- and time keeper records to each other.
timeKeeper_package.match (unit, start_date, end_date, empschd_tb, time_keeper_tb);
-- print out employee schedule records
utl_file.new_line(fip,1);
utl_file.put_line (fip, 'EMPLOYEE SCHEDULE RECORDS');
utl_file.new_line(fip,1);
if (empschd_tb.FIRST is not NULL) then
for j in empschd_tb.FIRST ..empschd_tb.LAST
loop
utl_file.put_line(fip, 'index: '||j||' match: '||empschd_tb(j).match||' empcode: '||
empschd_tb(j).empcd ||' '|| ' skill: '|| empschd_tb(j).skilltpe ||
' Home: ' || empschd_tb(j).hprdcode || ' Work: ' || empschd_tb(j).wprdcode ||
' Start: '|| to_char (empschd_tb(j).strtdate, 'MM/DD/YYYY HH:MI:SS AM') ||
' End: ' || to_char (empschd_tb(j).enddate, 'MM/DD/YYYY HH:MI:SS AM'), TRUE);
end loop;
end if;
-- print the time keeper scan data
utl_file.new_line(fip,1);
utl_file.put_line (fip, 'TIME KEEPER RECORDS');
utl_file.new_line(fip,1);
if (time_keeper_tb.FIRST is not NULL) then
for i in time_keeper_tb.FIRST ..time_keeper_tb.LAST
loop
utl_file.put_line(fip,'Index: '||i||' match: '|| time_keeper_tb(i).match||
' empcode: ' || time_keeper_tb(i).empcd ||
' Start: '|| to_char (time_keeper_tb(i).startscan, 'MM/DD/YYYY HH:MI:SS AM') ||
' End: ' || to_char (time_keeper_tb(i).endscan, 'MM/DD/YYYY HH:MI:SS AM'),TRUE);
end loop;
end if;
-- perform discrepancy logic between empschd and time keeper records
timeKeeper_indx := 1;
-- go through all empschd records
if (empschd_tb.FIRST is not NULL) then
for i in empschd_tb.FIRST ..empschd_tb.LAST loop
-- find the next time keeper record that has same empcode as current empschd
while (time_keeper_tb(timeKeeper_indx).empcd <= empschd_tb(i).empcd) loop
if (time_keeper_tb(timeKeeper_indx).match = 0) then
-- check if time keeper record is with in start and end date range if not
-- skip record else have a descrepancy which need to figured out. It can
-- only be 1 of 2 possiblities since there is no matching empshcd record.
if NOT((time_keeper_tb(timeKeeper_indx).startscan < start_date and
time_keeper_tb(timeKeeper_indx).endscan < start_date) or
(time_keeper_tb(timeKeeper_indx).startscan > end_date and
time_keeper_tb(timeKeeper_indx).endscan > end_date)) then
employee_index := empcode_find (time_keeper_tb(timeKeeper_indx).empcd,
empcode_tb, empcode_tb.LAST);
found := false;
-- figure out reason of descrepancy
if (employee_index < 0) then
found := true;
reason := 'Unknown Employee-Swipe';
else
found := true;
reason := 'Not Scheduled, Swipe-in';
end if;
if (found = true) then
add_discrepancy (unit,unknown_tb, belongWork_tb, floatIn_tb, floatOut_tb,
empcode_tb, employee_index,
empschd_tb, -1, time_keeper_tb, timeKeeper_indx, reason);
end if;
end if;
end if; -- end if time keeper match = 0
timeKeeper_indx := timeKeeper_indx + 1;
end loop; -- end while time keeper empcode <= empschd empcode
employee_index := empcode_find (empschd_tb(i).empcd, empcode_tb, empcode_tb.LAST);
found := false;
-- if current empschd has no match then check for descrepancy
if (empschd_tb(i).match = 0) then
if (employee_index < 0) then
found := true;
reason := 'Unknown Employee-Sched';
elsif ((empschd_tb(i).strtdate + unitgrace) < sysdate) then
found := true;
reason := 'Scheduled, no swipe-in';
end if;
if (found = true) then
add_discrepancy (unit,unknown_tb, belongWork_tb, floatIn_tb, floatOut_tb,
empcode_tb, employee_index,
empschd_tb, i, time_keeper_tb, -1, reason);
end if;
else
-- empschd has a match, check for descrepancies
case
when time_keeper_tb(empschd_tb(i).match).prodcode != empschd_tb(i).wprdcode and
empcode_tb(employee_index).home_swipe = 'N' then
found := true;
reason := 'Swiped into wrong unit';
when time_keeper_tb(empschd_tb(i).match).endscan is NULL and
(empschd_tb(i).enddate + unitgrace) < sysdate then
found := true;
reason := 'Swipe-in, no Swipe-out';
when (time_keeper_tb(empschd_tb(i).match).startscan + unitgrace) <
empschd_tb(i).strtdate then
found := true;
reason := 'Swipe-in early';
when (time_keeper_tb(empschd_tb(i).match).startscan - unitgrace) >
empschd_tb(i).strtdate then
found := true;
reason := 'Swipe-in late';
when (time_keeper_tb(empschd_tb(i).match).endscan + unitgrace) <
empschd_tb(i).enddate then
found := true;
reason := 'Swipe-out early';
when (time_keeper_tb(empschd_tb(i).match).endscan - unitgrace) >
empschd_tb(i).enddate then
found := true;
reason := 'Swipe-out late';
else
found := false;
end case;
if (found = true) then
add_discrepancy (unit,unknown_tb, belongWork_tb, floatIn_tb, floatOut_tb,
empcode_tb, employee_index,
empschd_tb, i, time_keeper_tb, empschd_tb(i).match, reason);
end if;
end if;
end loop; -- end for each empschd
-- process all unproccesed time_keeper records with match value of 0
while (timeKeeper_indx <= time_keeper_tb.LAST) loop
if (time_keeper_tb(timeKeeper_indx).match = 0) then
-- check if time keeper record is with in start and end date range if not
-- skip record else have a descrepancy which need to figured out. It can
-- only be 1 of 2 possiblities since there is no matching empshcd record.
if NOT((time_keeper_tb(timeKeeper_indx).startscan < start_date and
time_keeper_tb(timeKeeper_indx).endscan < start_date) or
(time_keeper_tb(timeKeeper_indx).startscan > end_date and
time_keeper_tb(timeKeeper_indx).endscan > end_date)) then
employee_index := empcode_find (time_keeper_tb(timeKeeper_indx).empcd,
empcode_tb, empcode_tb.LAST);
found := false;
-- figure out reason of descrepancy
if (employee_index < 0) then
found := true;
reason := 'Unknown Employee-Swipe';
else
found := true;
reason := 'Not Scheduled, Swipe-in';
end if;
if (found = true) then
add_discrepancy (unit,unknown_tb, belongWork_tb, floatIn_tb, floatOut_tb,
empcode_tb, employee_index,
empschd_tb, -1, time_keeper_tb, timeKeeper_indx, reason);
end if;
end if;
end if; -- end if time keeper match = 0
timeKeeper_indx := timeKeeper_indx + 1;
end loop; -- end while time keeper records unproccesed
else
utl_file.put_line (fip, 'In check time_keeper because empschd is NULL');
if (time_keeper_tb.FIRST is not NULL) then
utl_file.put_line (fip, 'In time keeper not null');
for i in time_keeper_tb.FIRST ..time_keeper_tb.LAST
loop
if NOT((time_keeper_tb(i).startscan < start_date and
time_keeper_tb(i).endscan < start_date) or
(time_keeper_tb(i).startscan > end_date and
time_keeper_tb(i).endscan > end_date)) then
employee_index := empcode_find (time_keeper_tb(i).empcd,
empcode_tb, empcode_tb.LAST);
found := false;
-- figure out reason of descrepancy
if (employee_index < 0) then
found := true;
reason := 'Unknown Employee-Swipe';
else
found := true;
reason := 'Not Scheduled, Swipe-in';
end if;
utl_file.put_line (fip, 'before if found true');
if (found = true) then
add_discrepancy (unit,unknown_tb, belongWork_tb, floatIn_tb, floatOut_tb,
empcode_tb, employee_index,
empschd_tb, -1, time_keeper_tb, timeKeeper_indx, reason);
utl_file.put_line (fip, 'after add discrepancy');
end if;
end if;
end loop;
end if;
end if;
-- print out discrepancy data
utl_file.put_line (fip, 'Unknown Employees');
if (unknown_tb.FIRST is not NULL) then
for j in unknown_tb.FIRST ..unknown_tb.LAST
loop
utl_file.put_line(fip, 'index: '||j|| ' empcode: '||unknown_tb(j).empcd ||
' skill: '||unknown_tb(j).skilltpe ||
' Home: '|| unknown_tb(j).hprdcode || ' Work: '||
unknown_tb(j).wprdcode||' Start: '||
to_char (unknown_tb(j).strtdate, 'MM/DD/YYYY HH:MI:SS AM') ||
' End: ' || to_char (unknown_tb(j).enddate, 'MM/DD/YYYY HH:MI:SS AM') ||
' Name: '|| unknown_tb(j).empfnme ||
' '||unknown_tb(j).empmint||' '|| unknown_tb(j).emplnme, TRUE);
utl_file.put_line(fip,'time prod: '||unknown_tb(j).prodcode||' scan start '||
to_char (unknown_tb(j).startscan, 'MM/DD/YYYY HH:MI:SS AM')||' scan end '||
to_char (unknown_tb(j).endscan, 'MM/DD/YYYY HH:MI:SS AM')||' Original start '||
to_char (unknown_tb(j).origstart, 'MM/DD/YYYY HH:MI:SS AM'), TRUE);
utl_file.put_line(fip, 'Reason: '|| unknown_tb(j).reason,TRUE);
utl_file.new_line(fip,1);
end loop;
end if;
utl_file.put_line (fip, 'Employees Belong and Work in Unit');
if (belongWork_tb.FIRST is not NULL) then
for j in belongWork_tb.FIRST ..belongWork_tb.LAST
loop
utl_file.put_line(fip, 'index: '||j|| ' empcode: '||belongWork_tb(j).empcd ||
' skill: '||belongWork_tb(j).skilltpe ||
' Home: '|| belongWork_tb(j).hprdcode ||
' Work: '|| belongWork_tb(j).wprdcode||' Start: '||
to_char (belongWork_tb(j).strtdate, 'MM/DD/YYYY HH:MI:SS AM') ||
' End: ' || to_char (belongWork_tb(j).enddate, 'MM/DD/YYYY HH:MI:SS AM') || ' Name: '||
belongWork_tb(j).empfnme ||
' '||belongWork_tb(j).empmint||' '|| belongWork_tb(j).emplnme, TRUE);
utl_file.put_line(fip,'time prod: '||belongWork_tb(j).prodcode||' scan start '||
to_char (belongWork_tb(j).startscan, 'MM/DD/YYYY HH:MI:SS AM')||' scan end '||
to_char (belongWork_tb(j).endscan, 'MM/DD/YYYY HH:MI:SS AM')||' Original start '||
to_char (belongWork_tb(j).origstart, 'MM/DD/YYYY HH:MI:SS AM'), TRUE);
utl_file.put_line(fip, 'Reason: '|| belongWork_tb(j).reason,TRUE);
utl_file.new_line(fip,1);
end loop;
end if;
utl_file.put_line (fip, 'Employees Floated into Unit');
if (floatIn_tb.FIRST is not NULL) then
for j in floatIn_tb.FIRST ..floatIn_tb.LAST
loop
utl_file.put_line(fip, 'index: '||j|| ' empcode: '||floatIn_tb(j).empcd ||
' skill: '|| floatIn_tb(j).skilltpe ||
' Home: '|| floatIn_tb(j).hprdcode ||
' Work: '|| floatIn_tb(j).wprdcode||' Start: '||
to_char (floatIn_tb(j).strtdate, 'MM/DD/YYYY HH:MI:SS AM') ||
' End: ' || to_char (floatIn_tb(j).enddate, 'MM/DD/YYYY HH:MI:SS AM') || ' Name: '||
floatIn_tb(j).empfnme ||
' '||floatIn_tb(j).empmint||' '|| floatIn_tb(j).emplnme, TRUE);
utl_file.put_line(fip,'time prod: '||floatIn_tb(j).prodcode||' scan start '||
to_char (floatIn_tb(j).startscan, 'MM/DD/YYYY HH:MI:SS AM')||' scan end '||
to_char (floatIn_tb(j).endscan, 'MM/DD/YYYY HH:MI:SS AM')||' Original start '||
to_char (floatIn_tb(j).origstart, 'MM/DD/YYYY HH:MI:SS AM'), TRUE);
utl_file.put_line(fip, 'Reason: '|| floatIn_tb(j).reason,TRUE);
utl_file.new_line(fip,1);
end loop;
end if;
utl_file.put_line (fip, 'Employees Floated out of unit');
if (floatOut_tb.FIRST is not NULL) then
for j in floatOut_tb.FIRST ..floatOut_tb.LAST
loop
utl_file.put_line(fip, 'index: '||j|| ' empcode: '||floatOut_tb(j).empcd ||
' skill: '||floatOut_tb(j).skilltpe ||
' Home: '|| floatOut_tb(j).hprdcode ||
' Work: '|| floatOut_tb(j).wprdcode||' Start: '||
to_char (floatOut_tb(j).strtdate, 'MM/DD/YYYY HH:MI:SS AM') ||
' End: ' || to_char (floatOut_tb(j).enddate, 'MM/DD/YYYY HH:MI:SS AM') || ' Name: '||
floatOut_tb(j).empfnme ||
' '||floatOut_tb(j).empmint||' '|| floatOut_tb(j).emplnme, TRUE);
utl_file.put_line(fip,'time prod: '||floatOut_tb(j).prodcode||' scan start '||
to_char (floatOut_tb(j).startscan, 'MM/DD/YYYY HH:MI:SS AM')||' scan end '||
to_char (floatOut_tb(j).endscan, 'MM/DD/YYYY HH:MI:SS AM')||' Original start '||
to_char (floatOut_tb(j).origstart, 'MM/DD/YYYY HH:MI:SS AM'), TRUE);
utl_file.put_line(fip, 'Reason: '|| floatOut_tb(j).reason,TRUE);
utl_file.new_line(fip,1);
end loop;
end if;
utl_file.fclose (fip);
end discrepancy;
procedure add_discrepancy (unit in prodcode.prodcode%type,
unknown_tb in out discrepancyArray,
belongWork_tb in out discrepancyArray,floatIn_tb in out discrepancyArray,
floatOut_tb in out discrepancyArray,
empcode_tb empcodeArray, empcdIndex pls_integer,
empschd_tb empArray,schdIndex pls_integer,
time_keeper_tb timeArray, timeIndex pls_integer, reason varchar2) as
array_tb discrepancyArray; -- current array to add discrepancy to
indx pls_integer; -- index of new record in current array
selector pls_integer; -- flag indicates which array record will
-- be added to. These are HBA Hard coded values
-- 1 - The unknown array
-- 2 - The belong and work in unit array
-- 3 - The floated into this unit array
-- 4 - The floated out of this unit array
begin
-- check if you have a valid employee, if not data goes into unknown_tb array
if (empcdIndex <= 0) then
array_tb := unknown_tb;
selector := 1;
-- if have no empschd record but do have time keeper, determine
-- which array data goes into
elsif (schdIndex <= 0 and timeIndex > 0) then
if (unit = time_keeper_tb(timeIndex).prodcode and
empcode_tb(empcdIndex).prodcode = unit) then
array_tb := belongWork_tb;
selector := 2;
elsif (unit = time_keeper_tb(timeIndex).prodcode and
empcode_tb(empcdIndex).prodcode != unit) then
array_tb := floatIn_tb;
selector := 3;
else
array_tb := floatOut_tb;
selector := 4;
end if;
-- if have employee schedule record, determine which array data
-- goes into. You should never be able to get past this point
elsif (schdIndex > 0) then
if (unit = empschd_tb(schdIndex).wprdcode and
empschd_tb(schdIndex).hprdcode = unit) then
array_tb := belongWork_tb;
selector := 2;
elsif (unit = empschd_tb(schdIndex).wprdcode and
empschd_tb(schdIndex).hprdcode != unit) then
array_tb := floatIn_tb;
selector := 3;
else
array_tb := floatOut_tb;
selector := 4;
end if;
end if;
-- create and add new record to the correct array
if (schdIndex > 0 or timeIndex > 0) then
-- determine index for the new record being created.
if (array_tb.LAST is NULL) then
indx := 1;
else
indx := array_tb.LAST + 1;
end if;
if (schdIndex > 0) then
array_tb(indx).empcd := empschd_tb(schdIndex).empcd;
array_tb(indx).skilltpe := empschd_tb(schdIndex).skilltpe;
array_tb(indx).hprdcode := empschd_tb(schdIndex).hprdcode;
array_tb(indx).wprdcode := empschd_tb(schdIndex).wprdcode;
array_tb(indx).strtdate := empschd_tb(schdIndex).strtdate;
array_tb(indx).enddate := empschd_tb(schdIndex).enddate;
array_tb(indx).empupdate := empschd_tb(schdIndex).lastupdate;
else
array_tb(indx).empcd := time_keeper_tb(timeIndex).empcd;
if (empcdIndex > 0) then
array_tb(indx).skilltpe := empcode_tb(empcdIndex).bskiltpe;
array_tb(indx).hprdcode := empcode_tb(empcdIndex).prodcode;
end if;
end if;
if (empcdIndex > 0) then
array_tb(indx).empfnme := empcode_tb(empcdIndex).empfnme;
array_tb(indx).empmint := empcode_tb(empcdIndex).empmint;
array_tb(indx).emplnme := empcode_tb(empcdIndex).emplnme;
end if;
if (timeIndex > 0) then
array_tb(indx).prodcode := time_keeper_tb(timeIndex).prodcode;
array_tb(indx).startscan := time_keeper_tb(timeIndex).startscan;
array_tb(indx).endscan := time_keeper_tb(timeIndex).endscan;
array_tb(indx).origstart := time_keeper_tb(timeIndex).origstart;
array_tb(indx).timeupdate := time_keeper_tb(timeIndex).lastupdate;
end if;
array_tb(indx).Reason := reason;
-- after new record created then reassign array to correct output variable
if (selector = 1) then
unknown_tb := array_tb;
elsif (selector = 2) then
belongWork_tb := array_tb;
elsif (selector = 3) then
floatIn_tb := array_tb;
elsif (selector = 4) then
floatOut_tb := array_tb;
end if;
end if;
end;
function empcode_find (empcd empcode.empcode%type, emcdTable empcodeArray,
maxIndex int) return int as
low int; -- Array index of low side of current search
high int; -- Array index of high side of current search
mid int; -- Array index of current record being checked
begin
low := 1; -- Initialize to first index in array
high := maxIndex; -- Initialize to last index in array
while ( low <= high) loop
mid := (low + high) / 2;
if (empcd < emcdTable(mid).empcd) then
high := mid - 1;
elsif (empcd > emcdTable(mid).empcd) then
low := mid + 1;
else
return mid;
end if;
end loop;
return -1;
end empcode_find;
procedure discrepancy2 (unit in prodcode.prodcode%type,
start_date date, end_date date,
unknown_tab out discrepTabTyp, belongWork_tab out discrepTabTyp,
floatIn_tab out discrepTabTyp, floatOut_tab out discrepTabTyp) as
unknown_tb discrepancyArray;
belongWork_tb discrepancyArray;
floatIn_tb discrepancyArray;
floatOut_tb discrepancyArray;
begin
timeKeeper_package.discrepancy (unit, start_date, end_date, unknown_tb,
belongWork_tb, floatIn_tb, floatOut_tb);
if (unknown_tb.FIRST is not NULL) then
unknown_tab := discrepTabTyp();
for j in unknown_tb.FIRST ..unknown_tb.LAST
loop
unknown_tab.extend;
unknown_tab(j) := discrepancyType (unknown_tb(j).empcd, unknown_tb(j).skilltpe,
unknown_tb(j).hprdcode, unknown_tb(j).wprdcode,
unknown_tb(j).strtdate, unknown_tb(j).enddate,
unknown_tb(j).empupdate,unknown_tb(j).empfnme,
unknown_tb(j).empmint, unknown_tb(j).emplnme, unknown_tb(j).prodcode,
unknown_tb(j).startscan, unknown_tb(j).endscan, unknown_tb(j).origstart,
unknown_tb(j).reason, unknown_tb(j).timeupdate);
end loop;
end if;
if (belongWork_tb.FIRST is not NULL) then
belongWork_tab := discrepTabTyp();
for j in belongWork_tb.FIRST ..belongWork_tb.LAST
loop
belongWork_tab.extend;
belongWork_tab(j) := discrepancyType (belongWork_tb(j).empcd,belongWork_tb(j).skilltpe,
belongWork_tb(j).hprdcode, belongWork_tb(j).wprdcode,
belongWork_tb(j).strtdate, belongWork_tb(j).enddate,
belongWork_tb(j).empupdate, belongWork_tb(j).empfnme,
belongWork_tb(j).empmint, belongWork_tb(j).emplnme, belongWork_tb(j).prodcode,
belongWork_tb(j).startscan, belongWork_tb(j).endscan, belongWork_tb(j).origstart,
belongWork_tb(j).reason, belongWork_tb(j).timeupdate);
end loop;
end if;
if (floatIn_tb.FIRST is not NULL) then
floatIn_tab := discrepTabTyp();
for j in floatIn_tb.FIRST ..floatIn_tb.LAST
loop
floatIn_tab.extend;
floatIn_tab(j) := discrepancyType (floatIn_tb(j).empcd,
floatIn_tb(j).skilltpe, floatIn_tb(j).hprdcode,
floatIn_tb(j).wprdcode, floatIn_tb(j).strtdate, floatIn_tb(j).enddate,
floatIn_tb(j).empupdate, floatIn_tb(j).empfnme,
floatIn_tb(j).empmint, floatIn_tb(j).emplnme, floatIn_tb(j).prodcode,
floatIn_tb(j).startscan, floatIn_tb(j).endscan, floatIn_tb(j).origstart,
floatIn_tb(j).reason, floatIn_tb(j).timeupdate);
end loop;
end if;
-- Copy float out table data to output array
if (floatOut_tb.FIRST is not NULL) then
floatOut_tab := discrepTabTyp();
for j in floatOut_tb.FIRST ..floatOut_tb.LAST
loop
floatOut_tab.extend;
floatOut_tab(j) := discrepancyType (floatOut_tb(j).empcd, floatOut_tb(j).skilltpe,
floatOut_tb(j).hprdcode, floatOut_tb(j).wprdcode,
floatOut_tb(j).strtdate, floatOut_tb(j).enddate,
floatOut_tb(j).empupdate, floatOut_tb(j).empfnme,
floatOut_tb(j).empmint, floatOut_tb(j).emplnme, floatOut_tb(j).prodcode,
floatOut_tb(j).startscan, floatOut_tb(j).endscan, floatOut_tb(j).origstart,
floatOut_tb(j).reason, floatOut_tb(j).timeupdate);
end loop;
end if;
end;
end timeKeeper_package;
GRANT EXECUTE ON TIMEKEEPER_PACKAGE TO public;
CREATE PUBLIC SYNONYM TIMEKEEPER_PACKAGE FOR TIMEKEEPER_PACKAGE;

Answer 1

I figured out that when I upgraded from 9.2.03 to 9.2.0.8 that the problem went away. I think when I had it working earlier I may have been on 9.2.0.5