 (
        p_StartJobID INTEGER,
        p_EndJobId INTEGER,
	    p_StartSchid INTEGER,
	    p_maxnodesnumber INTEGER
 )
DYNAMIC RESULT SETS 100
CALLED ON NULL INPUT
LANGUAGE SQL
 BEGIN

       --call EZViewer_CA7_AllPathsBetween (343 , 348, 1, 1000);
	
	    BEGIN
	   --A. Declare variable/Create temporary objects
           DECLARE v_StartJobID, v_EndJobId, v_StartSchid, v_maxnodesnumber INTEGER;
           DECLARE v_j, v_k INTEGER DEFAULT 1;
           DECLARE v_level INTEGER DEFAULT 1; -- allways the first job (tgt) in waiting stack will be processed
           DECLARE v_id INTEGER DEFAULT 1;
           DECLARE v_nodesnumber INTEGER DEFAULT 0;
           DECLARE v_maxiterations INTEGER DEFAULT 300000; -- safegard


           DECLARE v_src INTEGER;
           DECLARE v_tgt INTEGER;
           DECLARE v_ord INTEGER;
           DECLARE v_ssid INTEGER;
           DECLARE v_tsid INTEGER;
           DECLARE v_deptype INTEGER;
           DECLARE v_maxcycleid INTEGER;
           DECLARE v_maxpathid INTEGER;
           DECLARE v_pathid2 INTEGER;
           DECLARE v_tgt2 INTEGER;
           DECLARE v_id2 INTEGER;
           DECLARE v_ord12 INTEGER;
           DECLARE v_cycleid2 INTEGER;
           DECLARE v_ord2 INTEGER;
           DECLARE v_cyclejobid INTEGER;
           DECLARE v_cycleord INTEGER;


           DECLARE GLOBAL TEMPORARY TABLE SESSION.TempDiscovered
			(
			
			     ID INTEGER,
				 Flag INTEGER,
				 src INTEGER,
				 tgt INTEGER,
				 ord INTEGER,
				 ssid INTEGER,
				 tsid INTEGER,
				 deptype INTEGER
			)
			WITH REPLACE 
            ON COMMIT PRESERVE ROWS
			NOT LOGGED;


            DECLARE GLOBAL TEMPORARY TABLE SESSION.PreDiscovered
			(
			
			     ID INTEGER,
				 Flag INTEGER,
				 src INTEGER,
				 tgt INTEGER,
				 ord INTEGER,
				 ssid INTEGER,
				 tsid INTEGER,
				 deptype INTEGER
			)
			WITH REPLACE 
            ON COMMIT PRESERVE ROWS
			NOT LOGGED;


            DECLARE GLOBAL TEMPORARY TABLE SESSION.Discovered
			(
			
			     ID INTEGER,
				 src INTEGER,
				 tgt INTEGER,
				 ord INTEGER,
				 ssid INTEGER,
				 tsid INTEGER,
				 deptype INTEGER
			)
			WITH REPLACE 
            ON COMMIT PRESERVE ROWS
			NOT LOGGED;


           DECLARE GLOBAL TEMPORARY TABLE SESSION.TempCycle
			(
			    --ID INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1),
			     ID INTEGER,
				 cyclejobid INTEGER,
			     src INTEGER,
			     tgt INTEGER,
			     ord INTEGER,
			     ssid INTEGER,
			     tsid INTEGER,
			     deptype INTEGER
			)
			WITH REPLACE 
            ON COMMIT PRESERVE ROWS	
			NOT LOGGED;
					
			
				
			DECLARE GLOBAL TEMPORARY TABLE SESSION.PreCycle
			(
			
			     ID INTEGER,
				 cyclejobid INTEGER,
			     src INTEGER,
			     tgt INTEGER,
			     ord INTEGER,
			     ssid INTEGER,
			     tsid INTEGER,
			     deptype INTEGER
			)
			WITH REPLACE 
            ON COMMIT PRESERVE ROWS
			NOT LOGGED;


			
			DECLARE GLOBAL TEMPORARY TABLE SESSION.Cycle
			(
			     ID INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1),
				 cycleid INTEGER,
			     cyclejobid INTEGER,
			     src INTEGER,
			     tgt INTEGER,
			     ord INTEGER,
			     ssid INTEGER,
			     tsid INTEGER,
			     deptype INTEGER
			)
			WITH REPLACE 
            ON COMMIT PRESERVE ROWS
            NOT LOGGED;			

	
	        DECLARE GLOBAL TEMPORARY TABLE SESSION.Current_Stack
			(
			     ID INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1),
				 src INTEGER,
				 tgt INTEGER,
				 ord INTEGER,
				 ssid INTEGER,
				 tsid INTEGER,
				 deptype INTEGER
			)
			WITH REPLACE 
            ON COMMIT PRESERVE ROWS
			NOT LOGGED;



            DECLARE GLOBAL TEMPORARY TABLE SESSION.Processed
			(
			     ID INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1),
				 src INTEGER,
				 tgt INTEGER
			)
			WITH REPLACE 
            ON COMMIT PRESERVE ROWS
			NOT LOGGED;



           DECLARE GLOBAL TEMPORARY TABLE SESSION.PrePath
			(
			     ID INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1),
				 pathid INTEGER,
			     src INTEGER,
			     tgt INTEGER,
			     ord INTEGER,
			     ssid INTEGER,
			     tsid INTEGER,
			     deptype INTEGER
			)
             WITH REPLACE 
             ON COMMIT PRESERVE ROWS
			 NOT LOGGED;

	


           DECLARE GLOBAL TEMPORARY TABLE SESSION.Path
			(
			     pathtype INTEGER,
			     pathid INTEGER,
			     src INTEGER,
			     tgt INTEGER,
			     ord INTEGER,
			     ssid INTEGER,
			     tsid INTEGER,
			     deptype INTEGER
			)
			WITH REPLACE 
            ON COMMIT PRESERVE ROWS
			NOT LOGGED;



            DECLARE GLOBAL TEMPORARY TABLE SESSION.CA7_JobsTriggeredByJobs
			(
			    TriggeredBy_JobID INTEGER,
			    JobID INTEGER,
				inSCHID INTEGER,
				outSCHID INTEGER
			)
			WITH REPLACE 
            ON COMMIT PRESERVE ROWS
			NOT LOGGED;




           DECLARE GLOBAL TEMPORARY TABLE SESSION.CA7_JobsDependentOnJobs
			(
			    DependentOn_JobID INTEGER,
			    JobID INTEGER,
				SCHID INTEGER,
				DependencyTypeID INTEGER
			)
			WITH REPLACE 
            ON COMMIT PRESERVE ROWS
			NOT LOGGED;


 --B. Get basic data Job's relationship


         SET v_StartJobID     = p_StartJobID;
         SET v_EndJobId       = p_EndJobId;
		 SET v_StartSchid     = p_StartSchid;
		 SET v_maxnodesnumber = (SELECT (CASE WHEN p_maxnodesnumber > 5000 THEN 5000 ELSE p_maxnodesnumber END) FROM SYSIBM.SYSDUMMY1);
         SET v_maxnodesnumber = COALESCE(v_maxnodesnumber, 5000);

         INSERT INTO SESSION.CA7_JobsTriggeredByJobs (TriggeredBy_JobID, JobID, inSCHID, outSCHID)
         SELECT TriggeredBy_JobID, JobID, inSCHID, outSCHID
	     FROM CA7_JobsTriggeredByJobs;

	     INSERT INTO SESSION.CA7_JobsDependentOnJobs (DependentOn_JobID, JobID, SCHID, DependencyTypeID)
		 SELECT  DependentOn_JobID, JobID, SCHID, DependencyTypeID
		 FROM CA7_JobsDependentOnJobs;

         INSERT INTO SESSION.Discovered (ID, src, tgt, ord, ssid, tsid, deptype)
	     SELECT  1, CAST(NULL AS INTEGER), v_StartJobID, 0, v_StartSchid, v_StartSchid, CAST(NULL AS INTEGER) FROM SYSIBM.SYSDUMMY1;


--C. create appropriate indexes

        CREATE INDEX ncidx11 ON SESSION.CA7_JobsTriggeredByJobs (JobID ASC);
        CREATE INDEX ncidx12 ON SESSION.CA7_JobsTriggeredByJobs (TriggeredBy_JobID ASC, JobID ASC, inSCHID ASC, outSCHID ASC);
        CREATE INDEX ncidx21 ON SESSION.CA7_JobsDependentOnJobs (DependentOn_JobID ASC, JobID ASC, SCHID ASC, DependencyTypeID ASC);
        CREATE INDEX ncidx31 ON SESSION.PrePath (pathid ASC, ord ASC);
		CREATE INDEX ncidx32 ON SESSION.PrePath (src ASC, tgt ASC);
        CREATE INDEX ncidx41 ON SESSION.Current_Stack (src ASC, tgt ASC, ord ASC);
        CREATE INDEX ncidx51 ON SESSION.Processed (src ASC, tgt ASC);
        CREATE INDEX ncidx61 ON SESSION.Cycle (cycleid ASC, ord ASC);
	    CREATE INDEX ncidx62 ON SESSION.Cycle (cyclejobid ASC, src ASC, tgt ASC);


		WHILE  (v_maxiterations > v_level AND v_maxnodesnumber > v_nodesnumber) DO
		       BEGIN

						   -- get first job (tgt) for processing
						      SELECT  src, tgt, ord, ssid, tsid, deptype INTO v_src, v_tgt, v_ord, v_ssid, v_tsid, v_deptype  FROM SESSION.Discovered WHERE ID = v_id;
		

						       DELETE FROM SESSION.TempDiscovered WHERE 1 = 1; -- clean up temp stack

				
					       IF(
					          NOT EXISTS ( SELECT 1 FROM SESSION.Processed WHERE COALESCE(src,-1) = COALESCE(v_src,-1) AND COALESCE(tgt, -1) = COALESCE(v_tgt,-1))
					          ) 		
			               THEN
				
													--reset current stack
													DELETE FROM SESSION.Current_Stack WHERE ord >= v_ord;


													-- add JobID (tgt) into Current Stack
												    INSERT INTO SESSION.Current_Stack (src, tgt, ord, ssid,  tsid, deptype)
												    SELECT  v_src, v_tgt, v_ord, v_ssid,  v_tsid, v_deptype FROM SYSIBM.SYSDUMMY1;

													-- jobid (tgt) is marked as processed
												    INSERT INTO SESSION.Processed (src, tgt)
												    SELECT  v_src, v_tgt FROM SYSIBM.SYSDUMMY1
													EXCEPT
												    SELECT src, tgt FROM SESSION.Processed;

												

												    -- store the current path if we have reached the EndJob
												    IF(
												         EXISTS ( SELECT 1
															      FROM  SESSION.Current_Stack
															      WHERE tgt = v_EndJobId -- if last inserted is our searched Job (End Job)
																        AND ID = (SELECT MAX(ID) FROM SESSION.Current_Stack) -- on the last position
															      )
													   )
												    THEN		
														  INSERT INTO SESSION.PrePath (pathid, src, tgt, ord, ssid,  tsid, deptype)
														  SELECT v_Level AS pathid, src, tgt, ord, ssid,  tsid, depType
														  FROM  SESSION.Current_Stack
														  ORDER BY ord; 	
												    END IF;




												   -- prepare next level
												   -- get related jobs to v_tgt (next level of processing)

												   INSERT INTO SESSION.TempDiscovered (ID, Flag, src, tgt, ord, ssid, tsid, depType) -- get jobs (tgt) for next step/processing
												   SELECT ROW_NUMBER() OVER(ORDER BY t.src, t.tgt) AS ID,
												          1 AS Flag  -- discovered
														, t.src, t.tgt, t.ord, t.ssid, t.tsid, t.depType
												   FROM (
															  ----direct flow
															 SELECT e.TriggeredBy_JobID AS src,
																   e.JobID AS tgt,
																   v_ord + 1 AS ord,
																   CASE WHEN e.inSCHID = 0 THEN -ABS(v_tsid)
																	   ELSE e.inSCHID
																   END AS ssid,
																   CASE WHEN e.outSCHID = 0 AND e.inSCHID = 0 THEN -ABS(v_tsid)
																	   WHEN e.outSCHID = 0                   THEN -ABS(e.inSCHID)		
																	   ELSE e.outSCHID
																    END AS tsid,
																   -1 AS depType
															    FROM SESSION.CA7_JobsTriggeredByJobs e
															    WHERE    e.TriggeredBy_JobID = v_tgt
																	   AND e.TriggeredBy_JobID != v_EndJobID
																	   AND ( ABS(v_tsid) = ABS(e.inSCHID)
																		  OR (v_tsid = 0 AND v_StartSchid = 0 AND v_ord<>0)
																		  OR (e.inSCHID = 0 AND (
																							 v_ord <> 0 OR (
																											 (
																												SELECT COUNT(*)
																												FROM CA7_SchedulesPerJob spj
																												WHERE spj.JobID = v_tgt
																												    AND spj.SCHID = ABS(v_tsid)
																												)
																												+
																												(
																												SELECT COUNT(*)
																												FROM SESSION.CA7_JobsTriggeredByJobs jtj
																												WHERE jtj.JobID = v_tgt
																													   AND   COALESCE(NULLIF(jtj.outSCHID, 0), jtj.inSCHID) = ABS(v_tsid)
																												) > 0
																										  )
																							 )
																			 )
																		  )

		
																UNION

																-- dependency relation
																SELECT depe.DependentOn_JobID AS src,
																	  depe.JobID AS tgt,
																	  v_ord + 1 AS ord,
																	  CASE WHEN depe.SCHID = 0 THEN -ABS(v_tsid)
																		  ELSE depe.SCHID
																	  END AS ssid,-- ssid or tsid depending on how we interpret schid on dependency (also below in join)
																	  CASE WHEN depe.SCHID = 0 THEN -ABS(v_tsid)
																		  ELSE depe.SCHID
																	  END AS tsid,--same id
																	  depe.DependencyTypeID as depType
																FROM SESSION.CA7_JobsDependentOnJobs depe
																WHERE depe.DependentOn_JobID = v_tgt
																	 AND depe.DependentOn_JobID != v_EndJobID
																	 AND (
																		   depe.SCHID = 0
																		   OR
																		   depe.SCHID = ABS(v_tsid) -- ssid or tsid depending on how we interpret schid on dependency (also above in select)
																		)
									


													 ) t
													 ORDER BY  t.src, t.tgt;
		
		
		
		
		
		

													-- Cycle Area
													DELETE FROM SESSION.TempCycle WHERE 1 = 1;
													--TRUNCATE TABLE SESSION.TempCycle;
                                                    --ALTER TABLE SESSION.TempCycle ALTER COLUMN ID RESTART WITH 1;



											      -- INSERT INTO SESSION.TempCycle (ID, cyclejobid, src, tgt, ord, ssid, tsid, depType)
											       INSERT INTO SESSION.TempCycle (ID, cyclejobid, src, tgt, ord, ssid, tsid, depType)
												   SELECT ROW_NUMBER() OVER(ORDER BY t.ID) AS ID,
													      t.tgt AS cyclejobid , t.src, t.tgt, t.ord, t.ssid, t.tsid, t.depType
													FROM SESSION.TempDiscovered t
														 INNER JOIN SESSION.Current_Stack c ON c.tgt = t.tgt
													ORDER BY t.ID ;  -- job that will produce loop / cycle


                                                   SET v_j = (SELECT (SELECT MIN(ID) FROM  SESSION.TempCycle) FROM SYSIBM.SYSDUMMY1);
                                                   SET v_k = (SELECT (SELECT MAX(ID) FROM  SESSION.TempCycle) FROM SYSIBM.SYSDUMMY1);


													 -- if there are cycle candidates
													 WHILE (v_j <= v_k) DO

														  SELECT cyclejobid INTO v_cyclejobid FROM SESSION.TempCycle WHERE ID = v_j; -- get jobid that produce cycle
														  SELECT MAX(ord) INTO v_cycleord FROM SESSION.Current_Stack WHERE tgt = v_cyclejobid;   -- get cycle start position
	
	
                                                           DELETE FROM SESSION.PreCycle WHERE 1 = 1;

														   INSERT INTO SESSION.PreCycle (ID, cyclejobid, src, tgt, ord, ssid, tsid, depType)
														   SELECT ROW_NUMBER() OVER(ORDER BY ord) AS ID,
														          v_cyclejobid, src, tgt, ord - COALESCE(v_cycleord,0) AS ord, ssid, tsid, depType
															 FROM(
																 SELECT src, tgt, ord, ssid, tsid, depType
																 FROM SESSION.Current_Stack
																 WHERE ord >= v_cycleord

																 UNION
		
																 SELECT src, tgt, ord, ssid, tsid, depType
																 FROM SESSION.TempCycle
																 WHERE ID = v_j
																 )s
															  ORDER BY ord ;


														  -- check if the cycle wasn't already stored
														  IF (SELECT COUNT(*)
															  FROM (
																    SELECT cyclejobid, src, tgt, ord
																    FROM SESSION.PreCycle
																    EXCEPT
																    SELECT cyclejobid, src, tgt, ord
																    FROM SESSION.Cycle
																   )s
																)>0
														   THEN

														        SET v_maxcycleid = (SELECT (SELECT MAX(ID) FROM  SESSION.Cycle) FROM SYSIBM.SYSDUMMY1);
                                                                SET v_maxcycleid = COALESCE(v_maxcycleid, 0);

																INSERT INTO SESSION.Cycle (cycleid, cyclejobid, src, tgt, ord, ssid, tsid, depType)
																SELECT  v_maxcycleid as cycleid,  -- v_level + v_j AS cycleid,
																       cyclejobid, src, tgt, ord, ssid, tsid, depType
																FROM SESSION.PreCycle
																ORDER BY ID;

														   END IF;
						

														   SET v_j = v_j + 1;
														
														   COMMIT;
													END WHILE;


												-- End Cycle Area

                         ELSE
					
							    -- partial path
								-- this node is already in a path so we can consider
							    IF(
							        EXISTS( SELECT 1 FROM SESSION.PrePath WHERE COALESCE(src,-1) = COALESCE(v_src,-1) AND COALESCE(tgt, -1) = COALESCE(v_tgt,-1))
							       ) 		
		                        THEN
					
														--reset current stack
														DELETE FROM SESSION.Current_Stack WHERE ord >= v_ord;
	
	
														-- add JobID (tgt) into Current Stack
													    INSERT INTO SESSION.Current_Stack (src, tgt, ord, ssid,  tsid, deptype)
													    SELECT  v_src, v_tgt, v_ord, v_ssid,  v_tsid, v_deptype FROM SYSIBM.SYSDUMMY1;
	
	
	
													    -- insert partial path
													    INSERT INTO SESSION.PrePath ( pathid, src, tgt, ord, ssid,  tsid, deptype)
													    SELECT v_Level AS pathid, src, tgt, ord, ssid,  tsid, depType
													    FROM  SESSION.Current_Stack
													    ORDER BY ord;	
													
	
							    END IF;

						END IF;
				
				
				
				
				

				
				           DELETE FROM SESSION.PreDiscovered WHERE 1 = 1;

						  -- keep only unprocessed jobs
						   INSERT INTO SESSION.PreDiscovered (ID,Flag, src, tgt, ord, ssid, tsid, depType)
						   SELECT ROW_NUMBER() OVER(ORDER BY s.Flag, s.ID) AS ID,
						          s.Flag, s.src, s.tgt, s.ord, s.ssid, s.tsid, s.depType
						   FROM(   -- new jobs
								 SELECT t.ID, t.Flag
									    , t.src, t.tgt, t.ord, t.ssid, t.tsid, t.depType
								 FROM SESSION.TempDiscovered t
									 LEFT OUTER JOIN SESSION.Current_Stack c ON c.tgt = t.tgt  -- avoide cycle
								 WHERE c.ID IS NULL
								
								 UNION
								 -- move unprocessed jobs (tgt) from waiting stack to temp stack for later processing
								 SELECT ID, 2 AS Flag  -- old jobs moved
									    , src, tgt, ord, ssid,  tsid, deptype
								 FROM SESSION.Discovered
								 WHERE ID > v_id
								 )s
						   ORDER BY s.Flag, s.ID, s.src, s.tgt;




						  -- clean waiting stack
						  DELETE FROM SESSION.Discovered WHERE 1 = 1;
	
						  -- insert the jobs (tgt) into waiting stak  ( reordered -> new jobs in front)
						  INSERT INTO SESSION.Discovered (ID, src, tgt, ord, ssid, tsid, deptype)
						  SELECT ROW_NUMBER() OVER(ORDER BY Flag, ID) AS ID,
						         src, tgt, ord, ssid, tsid, deptype
						  FROM SESSION.PreDiscovered
						  ORDER BY Flag, ID, src, tgt;
				
				

	

                END ; -- atomic


                -- count number of nodes processed
                SET v_nodesnumber = (  SELECT COUNT(DISTINCT node)
                                       FROM
											(	
											    SELECT src as node
											    FROM SESSION.Processed
											    UNION
											    SELECT tgt as node
											    FROM SESSION.Processed		
											 )y );
											
				SET v_nodesnumber = COALESCE(v_nodesnumber, 0);							








			   IF
			      (
			       EXISTS( SELECT 1 FROM SESSION.Discovered )
			      )  --check if there are jobs to be processed
	            THEN
	                 SET v_level = v_level + 1;
			    ELSE
			         SET v_level = v_maxiterations; -- exit if nothing to process
			    END IF;


				/*
								
				COMMIT;				
								
				INSERT INTO Discovered_Test(lvl, ID, src, tgt, ord, ssid, tsid, depType)
				SELECT v_level, ID, src, tgt, ord, ssid, tsid, depType FROM SESSION.Discovered;

				INSERT INTO Current_Stack_Test (lvl, ID, src, tgt, ord, ssid,  tsid, deptype)
				SELECT v_level, ID, src, tgt, ord, ssid,  tsid, deptype FROM  SESSION.Current_Stack;
					
				INSERT INTO Cycle_Test (lvl, ID, cycleid, cyclejobid, src, tgt, ord, ssid, tsid, depType)
				SELECT  v_level, ID, cycleid, cyclejobid, src, tgt, ord, ssid, tsid, depType FROM SESSION.Cycle;

				INSERT INTO PrePath_Test ( lvl, ID, pathid, src, tgt, ord, ssid,  tsid, deptype)
				SELECT v_level, ID, pathid, src, tgt, ord, ssid,  tsid, depType FROM  SESSION.PrePath;	

				INSERT INTO Processed_Test (lvl, ID, src, tgt, TS)
				SELECT v_level, ID, src, tgt, current timestamp FROM SESSION.Processed;

				
				call EZViewer_CA7_AllPathsBetween (343 , 348, 1, 1000);



                 -- prepare tests
				CREATE TABLE Discovered_Test
							(
								  ID0 INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1),
								 lvl INTEGER,
								 ID INTEGER,
								 src INTEGER,
								 tgt INTEGER,
								 ord INTEGER,
								 ssid INTEGER,
								 tsid INTEGER,
								 deptype INTEGER
							) IN EZPR1.SDSPACE;
							
							
							
				CREATE TABLE Cycle_Test
							(
								 ID0 INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1),
								 lvl INTEGER,
								 ID INTEGER,
								 cycleid INTEGER,
								 cyclejobid INTEGER,
								 src INTEGER,
								 tgt INTEGER,
								 ord INTEGER,
								 ssid INTEGER,
								 tsid INTEGER,
								 deptype INTEGER
							) IN EZPR1.SDSPACE;		
							
							
							
				CREATE TABLE Current_Stack_Test
							(
								ID0 INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1),
								 lvl INTEGER,
								 ID INTEGER ,
								 src INTEGER,
								 tgt INTEGER,
								 ord INTEGER,
								 ssid INTEGER,
								 tsid INTEGER,
								 deptype INTEGER
							) IN EZPR1.SDSPACE;


					
							CREATE TABLE Processed_Test
							(
								 ID0 INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1),
								  lvl INTEGER,			
								 ID INTEGER ,
								 src INTEGER,
								 tgt INTEGER,
								 TS TIMESTAMP
							) IN EZPR1.SDSPACE;



						   CREATE TABLE PrePath_Test
							(
								 ID0 INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1),
								  lvl INTEGER,
								 ID INTEGER ,
								 pathid INTEGER,
								 src INTEGER,
								 tgt INTEGER,
								 ord INTEGER,
								 ssid INTEGER,
								 tsid INTEGER,
								 deptype INTEGER
							) IN EZPR1.SDSPACE;		


							
				SELECT * FROM  Discovered_Test order by ID0;

				SELECT * FROM   Current_Stack_Test FETCH FIRST 20 ROWS only; --order by ID0;
					
				SELECT * FROM   Cycle_Test order by ID0;

				SELECT * FROM   PrePath_Test  order by ID0;

				SELECT count(*) FROM  Processed_Test with UR ;--where lvl in ( 2950, 2951) order by ID0;


				TRUNCATE TABLE Discovered_Test;
				TRUNCATE TABLE Current_Stack_Test  ;
				TRUNCATE TABLE Cycle_Test  ;
				TRUNCATE TABLE PrePath_Test  ;
				TRUNCATE TABLE Processed_Test  ;

				
				
				*/

        COMMIT;
        END WHILE;




		     -- A direct
		     --add into final table direct pathid
			    INSERT INTO SESSION.Path(pathid, pathtype, src, tgt, ord, ssid,  tsid, deptype)
			    SELECT pp.pathid, 0 AS pathtype, pp.src, pp.tgt, pp.ord, pp.ssid, pp.tsid, pp.depType
			    FROM SESSION.PrePath pp;
			
				SET v_maxpathid = (SELECT MAX(pathid) FROM SESSION.PrePath);
			
				INSERT INTO SESSION.Path(pathid, pathtype, src, tgt, ord, ssid,  tsid, deptype)
				SELECT v_maxpathid + cc.CycleID + 1 AS pathid, 1 AS pathtype, cc.src, cc.tgt, cc.ord, cc.ssid,  cc.tsid, cc.deptype
				FROM SESSION.cycle cc
				     INNER JOIN (
				                 SELECT DISTINCT tgt
				                 FROM SESSION.PrePath
				                 ) pp ON pp.tgt = cc.cyclejobid;
	
	
	
	
	
                 BEGIN

					    DECLARE crs CURSOR WITH RETURN FOR	
						SELECT pp.pathid, pp.src, pp.tgt, pp.ord, pp.ssid, pp.tsid, pp.depType
						--SELECT pp.pathid, pp.pathtype, pp.src, pp.tgt, pp.ord, pp.ssid, pp.tsid, pp.depType
						FROM SESSION.Path pp
						ORDER BY pp.pathid, pp.ord;



                        OPEN crs;


                  END;

        END;

END	
