LANGUAGE SQL
BEGIN

	            BEGIN
			      COMMIT;
				  TRUNCATE TABLE cacheEZViewer_Usage_IMSDB_Physical IMMEDIATE ;
	              --DELETE FROM cacheEZViewer_Usage_IMSDB_Physical ;
	            END;


	
                LOCK TABLE  cacheEZViewer_Usage_IMSDB_Physical IN EXCLUSIVE MODE ;-- lock table
				INSERT INTO cacheEZViewer_Usage_IMSDB_Physical
				SELECT  SegmentID, SegmentName, SegmentStartRow, SegmentStartCol, SegmentEndRow, SegmentEndCol,  pth1.PathStr AS SegPath,
					    SegmentDBId AS DBId, SegmentDBName AS DBName, SegmentDBAccessTypeId AS AccessTypeId, IMSDBStartRow, IMSDBStartCol, IMSDBEndRow, IMSDBEndCol, pth2.PathStr AS IMSDBPath,
					    LogicalSegmentId, LogicalSegmentName, LogicalSegmentDBId, LogicalSegmentDBName,
				        StatementTypeID, Description, StatementStartRow, StatementStartColumn, StatementEndRow, StatementEndColumn, pth3.PathStr AS StmtPathStr,
				        ProgramID, ProgramName, ProgramTypeID, ProgStartRow, ProgStartCol, ProgEndRow, ProgEndCol, pth4.PathStr AS ProgramPath, Ancestor, AncestorID, AncestorTypeID,
						FieldID, FieldName, pth5.PathStr AS FieldPath, FieldStartRow, FieldStartCol, FieldEndRow, FieldEndCol, FieldSeq
				FROM (
						  SELECT
							    sgmt.SegmentID,
								sgmt.SegmentName,
								occ_SG.StartRow AS SegmentStartRow,
								occ_SG.StartCol AS SegmentStartCol,
								occ_SG.EndRow   AS SegmentEndRow,
								occ_SG.EndCol   AS SegmentEndCol,
								occ_SG.PathID   AS SegmentPathID,
								
								sgmt.SegmentDBId,
								sgmt.SegmentDBName,
								sgmt.SegmentDBAccessTypeId,
								occ_DB.StartRow AS IMSDBStartRow,
								occ_DB.StartCol AS IMSDBStartCol,
								occ_DB.EndRow   AS IMSDBEndRow,
								occ_DB.EndCol   AS IMSDBEndCol,
								occ_DB.PathID   AS IMSDBPathID,
				
								case when sgmt.SourceSegmentID is not null then sgmt.LogicalSegmentId else null end as LogicalSegmentId,
								case when sgmt.SourceSegmentID is not null then sgmt.LogicalSegmentName else null end as LogicalSegmentName,
								case when sgmt.SourceSegmentID is not null then sgmt.LogicalSegmentDBId else null end as LogicalSegmentDBId,
								case when sgmt.SourceSegmentID is not null then sgmt.LogicalSegmentDBName else null end as LogicalSegmentDBName,
				
								core.StatementTypeID,
							    core.Description,
							     core.StartRow AS StatementStartRow,
							     core.StartCol AS StatementStartColumn,
							     core.EndRow AS StatementEndRow,
							     core.EndCol AS StatementEndColumn,
							     core.PathID AS StmtPathID,
				
								prog.ProgramName,
								prog.ProgramID,
								prog.ProgramTypeID,
								prog.StartRow AS ProgStartRow,
								prog.StartCol AS ProgStartCol,
								prog.EndRow AS ProgEndRow,
								prog.EndCol AS ProgEndCol,
								prog.PathID AS ProgramPathID,
								prog.Ancestor,
								prog.AncestorID,
								prog.AncestorTypeID,
								field.FieldId,
								COALESCE(field.FieldName, 'N/A') AS FieldName,
								field.PathID AS FieldPathId,
								field.StartRow AS FieldStartRow,
								field.StartCol AS FieldStartCol,
								field.EndRow AS FieldEndRow,
								field.EndCol AS FieldEndCol,
								field.Seq AS FieldSeq
						  FROM (
								SELECT sr.ResourceID,
									   sr.OccurID,
									   os.ProgID,
									   os.PathID,
									   os.StartRow,
									   os.StartCol,
									   os.EndRow,
									   os.EndCol,
									   st.StatementType AS StatementTypeID,
									   st.Description
								FROM StatementReference sr
									 INNER JOIN OccurrencesStmt os ON sr.OccurID = os.OccurID
									 INNER JOIN Statements st ON sr.StatementType = st.StatementType
								WHERE sr.ResourceType = 209 -- IMS SEGMENT
									  AND  os.PathID IS NOT NULL
				
							    )core
							    INNER JOIN ( -- programs
										      SELECT p.ProgramID, p.ProgramName, p.ProgramTypeID,
												   occ.StartRow, occ.StartCol, occ.EndRow, occ.EndCol, occ.PathID,
												   p.Ancestor, pa.ProgramID AS AncestorID, pa.ProgramTypeID AS AncestorTypeID
											  FROM
                                                  (
													 SELECT pg.ProgramID,
															pg.Ancestor,
															pg.ProgramTypeID,
															pg.OccurID,
															px.AliasName AS ProgramName
													  FROM Programs pg
														   INNER JOIN ProgramAliases px ON pg.ProgramID = px.ProgramId AND px.AliasType = 0
								                   )  p
												   INNER JOIN Occurrences occ ON p.OccurID = occ.OccurID
												   LEFT OUTER JOIN
																   (
																	 SELECT DISTINCT
																	        pg.ProgramID,
																			--pg.Ancestor,
																			pg.ProgramTypeID,
																			--pg.OccurID,
																			--px.AliasName AS ProgramName,
																			px.AliasName AS ProgramName
																	  FROM Programs pg
																		   INNER JOIN ProgramAliases px ON pg.ProgramID = px.ProgramId
																   )  pa ON pa.ProgramName = p.Ancestor
											  WHERE occ.PathID IS NOT NULL
										) prog ON core.ProgID = prog.ProgramID
				                   INNER JOIN ( -- segments
										           SELECT  sg.SegmentId AS LogicalSegmentId,
													    sg.SegmentName AS LogicalSegmentName,
													    sg.OccurId AS LogicalSegmentOccurID,
													    db.DBId AS LogicalSegmentDBId,
													    db.DBName AS LogicalSegmentDBName,
													    db.AccessTypeId AS LogicalSegmentDBAccessTypeId,
													    db.OccurID AS LogicalSegmentDBOccurID,
				
													    srcsg.SegmentID AS SourceSegmentID,
													    srcsg.SegmentName AS SourceSegmentName,
													    srcsg.SegmentOccurID AS SourceSegmentOccurID,
													    srcsg.DBID AS SourceSegmentDBId,
													    srcsg.DBName AS SourceSegmentDBName,
													    srcsg.AccessTypeId AS SourceSegmentDBAccessTypeId,
													    srcsg.DBOccurID AS SourceSegmentDBOccurId,
				
													    --prepare final output
													      CASE WHEN srcsg.SegmentID IS NOT NULL THEN srcsg.SegmentID
															 ELSE sg.SegmentId
														 END AS SegmentID,
														 CASE WHEN srcsg.SegmentID IS NOT NULL THEN srcsg.SegmentName
															 ELSE sg.SegmentName
														 END AS SegmentName,
														 CASE WHEN srcsg.SegmentID IS NOT NULL THEN srcsg.SegmentOccurID
															 ELSE sg.OccurId
														 END AS SegmentOccurID,
														 CASE WHEN srcsg.SegmentID IS NOT NULL THEN srcsg.DBID
															 ELSE db.DBId
														 END AS SegmentDBId,
														 CASE WHEN srcsg.SegmentID IS NOT NULL THEN srcsg.DBName
															 ELSE db.DBName
														 END AS SegmentDBName,
														 CASE WHEN srcsg.SegmentID IS NOT NULL THEN srcsg.AccessTypeId
															 ELSE db.AccessTypeId
														 END AS SegmentDBAccessTypeId,
														 CASE WHEN srcsg.SegmentID IS NOT NULL THEN srcsg.DBOccurID
															 ELSE db.OccurID
														 END AS SegmentDBOccurID
												 FROM IMSDBSegments sg
													  INNER JOIN IMSDBInfo db ON db.DBId = sg.DBId
													  LEFT OUTER JOIN  -- info related to source segment
																 (
																   SELECT sg.SegmentID, sg.SegmentName, sg.OccurID AS SegmentOccurID,
																          sg.DBID, db.DBName, db.AccessTypeId, db.OccurID AS DBOccurID
																    FROM IMSDBSegments sg
																	   INNER JOIN IMSDBInfo db ON db.DBId = sg.DBId
																  ) srcsg ON sg.SourceSegId = srcsg.SegmentID
										  ) sgmt ON core.ResourceID = sgmt.LogicalSegmentId AND COALESCE(sgmt.SegmentDBAccessTypeId, 0) != 13 -- physical segments
												  LEFT OUTER JOIN Occurrences AS occ_SG ON occ_SG.OccurID = sgmt.SegmentOccurID
												  LEFT OUTER JOIN Occurrences AS occ_DB ON occ_DB.OccurID = sgmt.SegmentDBOccurID
								   LEFT OUTER JOIN ( -- search fields
											 SELECT
													 sr.OccurId AS StmtOccurId,
													 f.FieldId,
													 f.FieldName,
													 f.SegmentId,
													 f.Seq,
													 os.PathID,
													 os.StartRow,
													 os.StartCol,
													 os.EndRow,
													 os.EndCol
											 FROM StatementReference sr
												  INNER JOIN IMSDBFields f on sr.ResourceID = f.FieldId and sr.ResourceType = 222  -- IMS SSA search field
												  LEFT OUTER JOIN Occurrences os ON f.OccurID = os.OccurID
									  ) field on core.OccurId = field.StmtOccurId AND field.SegmentId = core.ResourceId			  
										  GROUP BY  sgmt.SegmentID, sgmt.SegmentName, occ_SG.StartRow, occ_SG.StartCol, occ_SG.EndRow, occ_SG.EndCol, occ_SG.PathID,
										            sgmt.SegmentDBId, sgmt.SegmentDBName, sgmt.SegmentDBAccessTypeId, occ_DB.StartRow, occ_DB.StartCol, occ_DB.EndRow, occ_DB.EndCol, occ_DB.PathID,
												    sgmt.SourceSegmentID, sgmt.LogicalSegmentId, sgmt.LogicalSegmentName, sgmt.LogicalSegmentDBId, sgmt.LogicalSegmentDBName,
				                                    core.StatementTypeID, core.Description,  core.StartRow,  core.StartCol, core.EndRow, core.EndCol, core.PathID,
				                                    prog.ProgramName, prog.ProgramID, prog.ProgramTypeID, prog.StartRow, prog.StartCol, prog.EndRow, prog.EndCol, prog.PathID, prog.Ancestor, prog.AncestorID, prog.AncestorTypeID,
													field.fieldID, field.fieldName, field.PathID, field.StartRow, field.StartCol, field.EndRow, field.EndCol, field.Seq
				
						  )c
						   LEFT OUTER JOIN  Paths pth1 ON pth1.PathID = c.SegmentPathID
						   LEFT OUTER JOIN  Paths pth2 ON pth2.PathID = c.IMSDBPathID
						   LEFT OUTER JOIN  Paths pth3 ON pth3.PathID = c.StmtPathID
						   LEFT OUTER JOIN  Paths pth4 ON pth4.PathID = c.ProgramPathID
						   LEFT OUTER JOIN  Paths pth5 ON pth5.PathID = c.FieldPathID;

                COMMIT;  						

END 
