//12/27/17 9:30PM. //FILE: rev.QUERY.PROBLEM.txt BEGIN TRANSACTION; //USING THESE TYPES FOR ATTRIBUTE LEVEL IN RESULT.NEST.SPLIT.REL (AND ELSEWHERE). TYPE LVL POSSREP (LV INT); //LVL IS THE LEVEL PART. TYPE DEL POSSREP (DL CHAR); //DEL IS THE DELIMITER/SDEL PART. TYPE LEVEL POSSREP (L LVL,D DEL); //ATTRIBUTE LEVEL WILL NOW LOOK LIKE: LEVEL(LVL(2),DEL(".")) OPERATOR BRACKET.DELIMITER(DELIMITER CHAR,LENGTHDEL INT)RETURNS CHAR; VAR BRACKETED.DELIMITER CHAR; VAR M1 INT; VAR CHAR CHAR; //TO GET VARIOUS KINDS OF REGULAR EXPRESSIONS, IE. // "[A-Z]" , " [A-Z]+[0-9]" , "[^A-Z]+GF" , "[0-9]+[A-Z]+XY " ETC. IF ( (STARTS_WITH(TRIM(DELIMITER),"[")) AND ( (ENDS_WITH(TRIM(DELIMITER),"]")) OR ( (INDEX_OF(TRIM(DELIMITER),"]+")>-1) AND (ENDS_WITH(TRIM(DELIMITER),"]")=FALSE) ) ) ) THEN RETURN TRIM(DELIMITER); END; //THIS IS FOR GROUPS OF CHARACTERS, IE, "(?<=\\G...)" OR EXPR. THAT IS IN PARENTHESIS, IE. "(\\s*;\\s*)". //FOR "(\\s*;\\s*)" SEE: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split IF ( (STARTS_WITH(TRIM(DELIMITER),"(?<=") OR STARTS_WITH(TRIM(DELIMITER),"(")) AND (ENDS_WITH(TRIM(DELIMITER),")")) ) THEN RETURN TRIM(DELIMITER); END; DO M1:=0 TO (LENGTHDEL-1); CHAR:=SUBSTRING(DELIMITER,M1,M1+1); BRACKETED.DELIMITER:=BRACKETED.DELIMITER || "[" || IF (NOT MATCHES(CHAR,"[\\\\\\[^]")) THEN "" ELSE "\\" END || CHAR || "]"; END; RETURN BRACKETED.DELIMITER; END; OPERATOR Rel.SPLIT(STR CHAR,SDEL CHAR,REVERSE.COUNTER BOOL) RETURNS SAME_TYPE_AS((REL{SPLIT("","")[0]} EXTEND{CTK:=0}){CTK,str}); RETURN IF (NOT (REVERSE.COUNTER)) THEN (SEQUENCE(0,COUNT(SPLIT(STR,SDEL))-1) EXTEND {CTK:=N+1,str:=str FROM SPLIT(STR,SDEL)[N]}){CTK,str} ELSE (SEQUENCE(0,COUNT(SPLIT(STR,SDEL))-1) EXTEND {CTK:=N+1,str:=str FROM SPLIT(STR,SDEL)[(COUNT(SPLIT(STR,SDEL))-(N+1))]}){CTK,str} END; END; //VAR sys.rev.Query REAL RELATION {Name CHARACTER, xpos INTEGER, ypos INTEGER, kind CHARACTER, connections RELATION {parameter INTEGER, Name CHARACTER}, model CHARACTER} KEY {Name}; sys.rev.Query := RELATION {Name CHARACTER, xpos INTEGER, ypos INTEGER, kind CHARACTER, connections RELATION {parameter INTEGER, Name CHARACTER}, model CHARACTER} { TUPLE {Name "EXTEND79851", xpos 490, ypos 105, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Expression79846"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "EXTEND80351", xpos 3788, ypos 472, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "UNGROUP80268"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "EXTEND80601", xpos 3919, ypos 884, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "UNGROUP80518"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "EXTEND80851", xpos 4086, ypos 1283, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "UNGROUP80768"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "EXTEND81787", xpos 4251, ypos 1687, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "UNGROUP81704"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "EXTEND82857", xpos 4606, ypos 2096, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "GROUP82528"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "EXTEND87393copy", xpos 86, ypos 291, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Expression87323copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "EXTEND87394copy", xpos 34, ypos 394, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND87393copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "EXTEND87406copy", xpos 92, ypos 586, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND87394copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "EXTEND87567copy", xpos 28, ypos 885, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Project87492copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "EXTEND87766copy", xpos 59, ypos 1163, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Project87667copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "EXTEND88068copy", xpos 76, ypos 1450, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Project87918copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "EXTEND91000copy", xpos 103, ypos 2678, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "GROUP89777copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "EXTEND91001copy", xpos 108, ypos 2821, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND91000copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "EXTEND91992copy", xpos 298, ypos 4022, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "UNWRAP91745copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "EXTEND92075copy", xpos 311, ypos 4321, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND91992copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "EXTEND92657copy", xpos 347, ypos 4961, kind "EXTEND", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "GROUP92574copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression104245", xpos 5, ypos 16, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression104360", xpos 6, ypos 98, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression104899", xpos 944, ypos 183, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression104900", xpos 552, ypos 288, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression105921", xpos 1234, ypos 394, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression106947", xpos 146, ypos 497, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression107532", xpos 1393, ypos 584, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression108367", xpos 392, ypos 696, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression110745", xpos 204, ypos 796, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression111538", xpos 446, ypos 1561, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression115919", xpos 315, ypos 1898, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression116204", xpos 179, ypos 1994, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression116961", xpos 358, ypos 2081, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression117656", xpos 403, ypos 2592, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression119242", xpos 577, ypos 2818, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression119811", xpos 418, ypos 2952, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression120304", xpos 273, ypos 3071, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression120305", xpos 200, ypos 3168, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression123736", xpos 454, ypos 3363, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression124419", xpos 456, ypos 3455, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression124747", xpos 460, ypos 3548, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression124748", xpos 640, ypos 3682, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression125033", xpos 347, ypos 3818, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression125400", xpos 352, ypos 3923, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression128340", xpos 372, ypos 4122, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression128341", xpos 375, ypos 4218, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression128662", xpos 378, ypos 4448, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression129727", xpos 363, ypos 4662, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression130117", xpos 387, ypos 4855, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression130312", xpos 395, ypos 5088, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression130597", xpos 421, ypos 5316, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Expression79846", xpos 184, ypos 11, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "Expression87323copy", xpos 59, ypos 182, kind "Expression", connections RELATION {parameter INTEGER, Name CHARACTER} { }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "GROUP82528", xpos 4514, ypos 2001, kind "GROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "RENAME81871"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "GROUP89363copy", xpos 72, ypos 2083, kind "GROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "UNGROUP88697copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "GROUP89528copy", xpos 82, ypos 2194, kind "GROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "GROUP89363copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "GROUP89611copy", xpos 86, ypos 2304, kind "GROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "GROUP89528copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "GROUP89694copy", xpos 94, ypos 2420, kind "GROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "GROUP89611copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "GROUP89777copy", xpos 107, ypos 2522, kind "GROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "GROUP89694copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "GROUP91497copy", xpos 188, ypos 3497, kind "GROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Project91414copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "GROUP92574copy", xpos 337, ypos 4752, kind "GROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Project92326copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Project80020", xpos 3356, ypos 309, kind "Project", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "UNGROUP79937"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "Project80352", xpos 3817, ypos 566, kind "Project", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND80351"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "Project80602", xpos 3940, ypos 988, kind "Project", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND80601"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "Project81538", xpos 4169, ypos 1382, kind "Project", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND80851"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "Project81788", xpos 4320, ypos 1795, kind "Project", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND81787"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "Project83205", xpos 4964, ypos 2186, kind "Project", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND82857"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "Project87492copy", xpos 42, ypos 790, kind "Project", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "UNGROUP87435copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Project87667copy", xpos 193, ypos 1058, kind "Project", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "UNGROUP87568copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Project87918copy", xpos 206, ypos 1346, kind "Project", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "UNGROUP87767copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Project88276copy", xpos 188, ypos 1783, kind "Project", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "UNGROUP88069copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Project91084copy", xpos 115, ypos 2954, kind "Project", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND91001copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Project91414copy", xpos 172, ypos 3262, kind "Project", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "UNGROUP91249copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Project92326copy", xpos 321, ypos 4541, kind "Project", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND92075copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "Project92658copy", xpos 373, ypos 5194, kind "Project", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND92657copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "RENAME80103", xpos 3689, ypos 277, kind "RENAME", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Project80020"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "RENAME80435", xpos 3770, ypos 664, kind "RENAME", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Project80352"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "RENAME80685", xpos 4015, ypos 1085, kind "RENAME", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Project80602"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "RENAME81621", xpos 4218, ypos 1490, kind "RENAME", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Project81538"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "RENAME81871", xpos 4435, ypos 1900, kind "RENAME", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Project81788"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "Restrict91662copy", xpos 194, ypos 3687, kind "Restrict", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "GROUP91497copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "UNGROUP79937", xpos 3342, ypos 212, kind "UNGROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND79851"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "UNGROUP80268", xpos 3862, ypos 380, kind "UNGROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "RENAME80103"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "UNGROUP80518", xpos 3942, ypos 770, kind "UNGROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "RENAME80435"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "UNGROUP80768", xpos 4079, ypos 1188, kind "UNGROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "RENAME80685"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "UNGROUP81704", xpos 4257, ypos 1585, kind "UNGROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "RENAME81621"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "UNGROUP83373", xpos 5040, ypos 2286, kind "UNGROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Project83205"} }, model "12/9/17 10:30PM. Query9/JUDY9"}, TUPLE {Name "UNGROUP87435copy", xpos 287, ypos 697, kind "UNGROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND87406copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "UNGROUP87568copy", xpos 78, ypos 1008, kind "UNGROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND87567copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "UNGROUP87767copy", xpos 109, ypos 1273, kind "UNGROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND87766copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "UNGROUP88069copy", xpos 107, ypos 1692, kind "UNGROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "WRAP88476copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "UNGROUP88697copy", xpos 228, ypos 1899, kind "UNGROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Project88276copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "UNGROUP91249copy", xpos 169, ypos 3073, kind "UNGROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Project91084copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "UNGROUP92823copy", xpos 386, ypos 5413, kind "UNGROUP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Project92658copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "UNWRAP91745copy", xpos 257, ypos 3820, kind "UNWRAP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "Restrict91662copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."}, TUPLE {Name "WRAP88476copy", xpos 86, ypos 1568, kind "WRAP", connections RELATION {parameter INTEGER, Name CHARACTER} { TUPLE {parameter 0, Name "EXTEND88068copy"} }, model "QUERY10 IN Rev FOR SPLITTING STRINGS."} } ; //VAR sys.rev.Operator REAL RELATION {Name CHARACTER, Definition CHARACTER} KEY {Name}; sys.rev.Operator := RELATION {Name CHARACTER, Definition CHARACTER} { TUPLE {Name "Expression104245", Definition "WRITELN \"README.FIRST.\"; WRITELN \"THIS IS QUERY10 FOR SPLITTING A STRING IN Rev. THE QUERY IS SLIGHTLY MODIFIED FROM THE QUERY10 SCRIPT.\"; WRITELN \"THIS Rev QUERY HAS COMMENTS. COMMENT(S) ARE CONTAINED IN AN \'EXPRESSION\' OPERATION THAT IS NOT CONNECTED TO ANY OTHER OPERATIONS.\"; WRITELN \"IN OTHER WORDS, THEY ARE ISOLATED EXPRESSIONS. THEY WORK LIKE ANY OF THE OTHER OPERATIONS, JUST CLICK ON THE \'>\' TO VIEW THEM.\"; WRITELN \"THE ONLY DIFFERENCE IS YOU ARE ONLY VIEWING THE COMMENT(S) CONTAINED IN A PARTICULAR EXPRESSION BECAUSE ALL COMMENT EXPRESSIONS ARE ISOLATED.\"; WRITELN \"COMMENT EXPRESSIONS ARE STRATEGICALLY PLACED, AS BEST AS POSSIBLE, SO YOU CAN HOPEFULLY INFER WHAT OPERATION(S) THEY ARE REFER TO.\"; WRITELN \"A COMMENT IS A WRITELN STATEMENT AND MULTIPLE COMMENTS IN AN EXPRESSION ARE MUPLTIPLE WRITELN STATEMENTS ON THE SAME LINE.\"; WRITELN \"MULTIPLE COMMENTS WILL FIRST DISPLAY AS A SINGLE LINE WITH THESE MULTIPLE WRITELN STATEMENTS. THE INDIVIDUAL WRITELN STATEMENTS WILL APPEAR RIGHT AFTER.\"; WRITELN \"TRY TO IGNORE THE SINGLE LINE WRITELN STATEMENT(S) AND CONCENTRATE ON THE TEXT OF THE COMMENTS THAT FOLLOWS.\"; WRITELN \"NOTE THAT WRITELN COMMENTS END IN A SEMI-COLON. ALL OPERATIONS CONCERNED WITH THE QUERY DO NOT INVOLVE SEMI-COLONS.\"; WRITELN \"THIS MEANS ALL QUERY OUTPUT IS EVALUATED AND NOT EXECUTED. THIS ENABLES YOU TO DISPLAY THE QUERY OR ANY PART OF THE QUERY WITH ENHANCED OUTPUT.\"; WRITELN \"ENHANCED OUTPUT IS A WONDERFUL AID IN UNDERSTANDING WHAT THE RELATIONAL ALGEBRA IS DOING. EVEN VIEWING THE RESULT IN ENHANCED OUPUT AND THEN VIEWING THE SAME RESULT IN NON-ENHANCED OUTPUT CAN HELP.\"; WRITELN \"FOR LONG COMMENTS IT IS RECOMMENDED YOU VIEW THEM IN NON-ENHANCED DISPLAY TO AVOID THE TEXT FROM WRAPPING.\"; WRITELN \"FINALLY FOR MULTIPLE COMMENTS THAT ARE VERY LONG, THE ENTIRE CONTAINING EXPRESSION MAY NOT FIT ON YOUR SCREEN. DON\'T PANIC.\"; WRITELN \"YOU DO NOT HAVE TO CLICK \'EXACTLY\' ON THE \'>\' TO VIEW THE COMMENTS. THE EXPRESSION IS ACTUALLY DIVIDED INTO TWO SECTIONS/PANELS THAT ARE SEPARATED. THE LEFT PANEL HAS A \'?\' WHICH IS NOT COVERED HERE (CLICK TO SEE ITS OPTIONS).\"; WRITELN \"THE RIGHT PANEL HAS THE \'>\' TO VIEW THE EXPRESSION/COMMENTS. YOU CAN CLICK ANYWHERE IN THE RIGHT PANEL TO VIEW THE COMMENTS.\"; WRITELN \"IT SHOULD BE OBVIOUS NOW THAT IF YOU SEE AN OBJECT/OPERATION THAT STARTS WITH A WRITELN STATEMENT THAT IT\'S A COMMENT(S).\"; WRITELN \"NOW PLEASE READ THE EXPRESSION/COMMENTS RIGHT AFTER THIS ONE TO FIX A PROBLEM WITHIN THE QUERY.\";"}, TUPLE {Name "Expression104360", Definition "WRITELN \"THE QUERY HAS A SLIGHT GLITCH. IT CAN BE FIXED OR YOU CAN CHOOSE TO IGNORE IT. IF YOU IGNORE IT THE QUERY WILL STILL WORK BUT YOU WON\'T BE ABLE TO CLICK ON THE PARTICULAR OPERATION THAT HAS A PROBLEM. THE PROBLEM IS A \'Project\' THAT HAS A YELLOWISH TOP INSTEAD OF A LIGHT PURPLISH TOP.\"; WRITELN \"THIS Project IS RIGHT AFTER AN \'UNGROUP\' OPERATON FOR ATTRIBUTE \'UNION.U.GRPS\'.\"; WRITELN \"A PURPLISH TOP INDICATES THE OPERATION IS OK AND CLICKING ON THE \'>\' WILL EXECUTE THE QUERY UP TO AND INCLUDING THE OPERATION.\"; WRITELN \"TO FIX THIS PROBLEM RIGHT CLICK ON THE Project AND CLICK \'Disconnect\'. THEN DRAG THE \'Operand\' OF THE Project AND RECONNECT IT TO THE ABOVE UNGROUP OPERATION.\"; WRITELN \"THE OPERATION AFTER THE Project IS A \'GROUP\', DRAG THE Operand OF THE GROUP AND RECONNECT IT TO THE Project.\"; WRITELN \"THE TOP OF THE Project SHOULD NOW BE A LIGHT PURPLISH TOP INDICATING THE Project IS NOW OK.\";"}, TUPLE {Name "Expression104899", Definition "WRITELN \"THE RELATION ON THE LEFT HOLDS THE STRINGS (INPUT.STR) THAT WILL BE SPLIT. YOU CAN EDIT THE RELATION TO CHANGE/REPLACE THE STRINGS.\";WRITELN \"TO EDIT CLICK ON THE RELATION. AN EXPRESSION BOX WILL APPEAR WHERE YOU MAKE CHANGES. USE A RIGHT CLICK FOR DELETING/PASTING ETC. CLICK OK WHEN FINISHED.\";"}, TUPLE {Name "Expression104900", Definition "WRITELN \"ATTRIBUTES SDEL1-SDEL5 ARE THE 5 DELIMITERS BEING USED. THEY COULD BE STORED IN A BASE RELATION THAT WOULD MAKE THINGS EASIER BUT INSTEAD WE\'RE ADDING THEM TO THE RELATION HERE.\";WRITELN \"THEIR VALUES WILL BE USED THROUGHOUT THE QUERY (WHEN NEEDED) SO HERE IS ONLY PLACE YOU NEED TO EDIT/CHANGE THEM.\"; WRITELN \"THEY WILL ALL BE REMOVED FROM THE QUERY WHEN THEY ARE NO LONGER NEEDED.\";WRITELN;WRITELN \"THE OVERALL GOAL OF THE QUERY IS TO CREATE A NORMALIZED RELATION WITH JUST A FEW ATTRIBUTES SHOWING THE ENTIRE SEQUENCE OF SPLITTING USING ALL 5 DELIMITERS.\";WRITELN \"BUT BEFORE THAT CAN BE DONE A DE-NORMALIZED RELATION WITH THE SPLIT RESULTS FROM ALL 5 DELIMITERS MUST BE CREATED.\";WRITELN \"THE FOLLOWING OPERATIONS SHOW A METHOD TO DO THIS.\";"}, TUPLE {Name "Expression105921", Definition "WRITELN \"THE DE-NORMAIZATION STAGE STARTS BY USING AN EXTEND OPERATION TO SPLIT EACH INPUT.STR FOR EACH ID. THIS CREATES A RVA (RELATIONAL VALUED ATTRIBUTE) NAMED SPLIT1.\"; WRITELN \"OPERATOR Rel.SPLIT DOES THE SPLITTING AND CREATES ATTRS. CTK AND str. THESE ARE RENAMED SO EACH SPLITTING HAS UNIQUE NAMES.\"; WRITELN \"BEFORE THIS EXTEND IS CLOSED ANOTHER EXTEND IS USED TO ADD ATTRS. SPLIT#1 AND NUMS#1 WHICH IS A UNIQUE INTEGER VALUE. AT THIS POINT BOTH EXTENDS ARE CLOSED.\"; "}, TUPLE {Name "Expression106947", Definition "WRITELN \"NOW THAT WE HAVE SPLIT1 STRINGS (str1) WE NEED TO SPLIT THEM BY DELIMITER 2 (SDEL2). PREVIOUS QUERYS TOOK THE TACT OF UNGROUPING RELATION SPLIT1 AND WORKING WITH str1 AS ATTRIBUTES ONLY, DISCONNECTED FROM ANY RELATION.\"; WRITELN \"WHILE WORKING WITH ATTRIBUTES IS SIMPLER TO WORK WITH THAN RELATIONS, WE WANT TO WORK WITH RELATIONS DIRECTLY HERE.\"; WRITELN \"WE WANT TO SPLIT THE str1 STRINGS WITH DELIMITER 2 WHERE THE str1 STRINGS REMAIN WITHIN RELATION SPLIT1. WE TAKE THIS APPROACH \"; WRITELN \"ONLY TO SHOW HOW POWERFUL AND FLEXIBLE TTM AS IMPLEMENTED IN Rel IS.\"; WRITELN \"SPLITTING EACH str1 BY DELIMITER 2 NOW AMOUNTS TO SPLITTING EACH TUPLE OF RELATION SPLIT1 WHICH IS AN ATTRIBUTE IN EACH OF THE 2 TUPLES (1 FOR EACH ID) OF THE OVERALL RELATION.\"; WRITELN \"BUT THERE IS NO WAY TO DIRECTLY ACCESS/SPLIT str1 BECAUSE str1 IS AN ATTRIBUTE OF SPLIT1 AND NOT AN ATTRIBUTE OF THE OVERALL RELATION. THIS IS ANOTHER WAY OF SAYING TUPLES WITH str1 ARE OUT OF SCOPE OF AN EXTEND.\"; WRITELN \"ONLY A RELATION CAN BE EXTENDED AND THAT RELATION MUST BE IN SCOPE. SO THE QUESTION IS HOW TO BRING SPLIT1 INTO SCOPE TO ACCESS ITS TUPLES.\"; WRITELN \"THE RELATION WE WANT TO EXTEND IS SPLIT1 SO WANT WE WANT TO USE THE EXPRESSION \'SPLIT1 EXTEND\'. THE ONLY OTHER RELATION AVAILABLE IS THE OVERALL RELATION.\"; WRITELN \"BUT THAT IS ALL THE INFORMATION REQUIRED. THE OVERALL RELATION CAN BE EXTENDED BY DEFINING ATTRIBUTE R1 WHICH EXTENDS SPLIT1 TO INCLUDE RELATION SPLIT2 WHICH ARE THE ATTRIBUTES OF SPLIT1 (str1) SPLIT BY DELIMITER 2.\"; WRITELN \"A SPLIT2 RELATION IS CREATED FOR EACH str1 TUPLE AND CONTAINS AS MANY TUPLES AS THE str1 STRING SPLIT BY DELIMITER 2 GENERATES, IE. 1 TUPLE FOR EACH STRING CREATED BY SDEL2.\";"}, TUPLE {Name "Expression107532", Definition "WRITELN \"THE \'EXTEND {R1:=SPLIT1\' PART OF THE EXPRESSION DEFINES R1 AS A RVA. THE OVERALL RELATION IS BEING EXTENDED TO ADD R1. R1 WILL THEREFORE BE AN ATTRIBUTE IN EACH TUPLE OF THE OVERALL RELATION, AN R1 FOR EACH ID.\"; WRITELN \"BECAUSE R1 IS BASED ON RELATION SPLIT1, THE FIRST ATTRIBUTES IN R1 WILL BE THE ATTRIBUTES IN RELATION SPLIT1. THE \'EXTEND {SPLIT2:=Rel.SPLIT(str1...\' PART OF THE EXPRESSION USES ATTRIBUTE str1 AS THE ARGUMENT TO Rel.SPLIT\"; WRITELN \"SO str1 CAN BE SPLIT BY DELIMITER 2. THE RESULT OF THIS SPLIT IS RELATION SPLIT2 WITH AS MANY TUPLES AS THE SPLIT CREATED (ATTRIBUTE CTK2). THIS PROCESS IS REPEATED FOR EACH str1 THAT OCCURS IN RELATION SPLIT1.\"; WRITELN \"THE LAST EXTEND IN THE EXPRESSION, \'EXTEND {SPLIT#2:=2, NUMS#2:=GET_UNIQUE_NUMBER()\', IS BASED ON RELATION SPLIT2 AND ADDS ATTRIBUTES SPLIT#2 AND NUMS#2 TO RELATION SPLIT2. AT THIS POINT ALL THE EXTENDS\"; WRITELN \"FOR R1 ARE CLOSED AND IT\'S IN THE OVERALL RELATION. THE QUESTION NOW IS HOW BEST TO USE R1.\";"}, TUPLE {Name "Expression108367", Definition "WRITELN \"KEEP IN MIND THE GOAL AT THIS POINT WHICH IS TO GET A DE-NORMALIZED RELATION WITH ALL THE INFORMATION FOR EACH SPLIT. WITH THE INFORMATION FOR EACH SPLIT BEING THE ATTRIBUTES OF EACH SPLIT.\"; WRITELN \"RELATION R1 HAS THE ATTRIBUTES OF THE 1ST SPLIT (WHICH BY THE WAY IS REDUDANT WITH RELATION SPLIT1). AND IT HAS RELATION SPLIT2 WHOSE str2 ATTRIBUTE WE NEED SO IT CAN BE SPLIT BY DELIMITER 3 (JUST LIKE ATTRIBUTE str1 FROM RELATION SPLIT1 WAS SPLIT BY DELIMITER 2).\"; WRITELN \"SO WE UNGROUP RELATION R1 WHICH ADDS THE SPLIT1 ATTRIBUTES (THERE ARE 4) TO THE OVERALL RELATION, A TUPLE FOR EACH SPLIT STRING AND WITHIN THAT TUPLE A RVA (RELATION VALUED ATTRIBUTE) SPLIT2. \"; WRITELN \"NOTE THAT FOR EVERY TUPLE THE UNGROUPING OF R1 ADDS TO THE OVERALL RELATION, RELATION SPLIT1 APPEARS IN EVERY TUPLE (FOR THE CORRESPONDING ID). NOW WHAT DO WE DO WITH RELATION SPLIT1 BECAUSE AT THIS POINT WE NO LONGER NEED IT.\";WRITELN \"THE ANSWER IS WE SIMPLY Project (REMOVE) SPLIT1 OUT OF THE OVERALL RELATION WHICH THE NEXT OPERATION DOES.\"; "}, TUPLE {Name "Expression110745", Definition "WRITELN \"THIS PROCESS OF DEFINING A NEW RELATION BASED ON EXTENDING THE LAST SPLIT RELATION, CREATING THE NEXT SPLIT RELATION, UNGROUING THE NEW RELATION AND REMOVING THE LAST SPLIT RELATION IS REPEATED (DEFINING RELATIONS R2, R3 AND R4) UNTIL RELATION SPLIT5 IS CREATED (BY RELATION R4) AND RELATION SPLIT5 IS ITSELF UNGROUPED.\"; WRITELN \"SOME THINGS TO BEAR IN MIND:\"; WRITELN \"EVERY SPLIT STRING IS ALWAYS PASSED ON TO THE NEXT DELIMITER FOR SPLITTING. A SPLIT STRING IS NEVER HELD BACK, NO MATTER THE REASON, FOR CONTINUING ON TO THE NEXT SPLIT. THIS IS EVIDENT WHEN A STRING IS CREATED EARLY ON THAT HAS NO OTHER DELIMITERS (MAXIMALLY SPLIT). THAT STRING WILL CONTINUE ON TO THRU DELIMITER 5 SINCE OPERATOR Rel.SPLIT WILL RETURN THE INPUT STRING IF THE DELIMITER ISN\'T PRESENT.\"; WRITELN \"WHEN A STRING IS SPLIT INTO MULTIPLE STRINGS, EACH NEW STRING IS PASSED ON TO THE NEXT DELIMITER.\"; WRITELN \"NOTE THAT SPLITTING CAN CAUSE DUPLICATED ATTRIBUTES FOR PRIOR DE-NORMALIZED SPLIT ATTRIBUTES. FOR EXAMPLE IN RELATION R1 FOR ID 2 str1 \'T*50*60$M$H#70#80$Q@END\' SPLIT BY SDEL2 (\'*\') CREATES 3 str2\'s. WHEN RELATION R2 IS UNGROUPED THE (4) ATTRIBUTES FOR THAT str1 ARE DUPLICATED 3 TIMES (ONCE FOR EVERY str2 CREATED) IN THE OVERALL RELATION.\"; WRITELN \"ALSO NOTICE THAT EVERY TIME YOU CLICK TO SEE PART OF THE SPLITTING OPERATIONS THE VALUES FOR ATTRIBUTES NUMS#N CHANGE. THIS IS BECAUSE THEY BASED ON THE FUNCTION GET_UNIQUE_NUMBER(). THIS FUNCTION IS ALWAYS GUARANTEED TO RETURN A UNIQUE INTEGER VALUE IN THE DATABASE. THE FACT THAT THEY CHANGE WITHIN SPLITTING IS NOT A PROBLEM BECAUSE THEY WILL BE UNIQUE VALUES.\";"}, TUPLE {Name "Expression111538", Definition "WRITELN \"JUST AS THERE IS A RVA (RELATIONAL VALUED ATTRIBUTE) THERE IS A TVA (TUPLE VALUED ATTRIBUTE). FOR THE TIME BEING THE VALUES OF THE DELIMITER ATTRIBUTES (SDEL1-SDEL5) ARE NOT NEEDED.\"; WRITELN \"THESE ATTRIBUTES CAN BE PLACED IN A TUPLE WITHIN ALL THE RELATION TUPLES THEY OCCUR IN AND THIS TUPLE CAN BE GIVEN A NAME. THIS NAME IS USED TO ADDRESS ALL THE ATTRIBUTES AT ONCE INSTEAD OF HAVING TO ADDRESS THEM INDIVIDUALLY.\"; WRITELN \"THIS OPERATION IS CALLED A WRAP OPERATION BECAUSE ALL THE ATTRIBUTES ARE WRAPPED TOGETHER. THIS IS A HANDY CONVENIENCE TO HAVE. WHEN THE INDIVIDUAL ATTRIBUTE VALUES ARE NEEDED THE WRAPPED ATTRIBUTES CAN BE UNWRAPPED SIMILAR TO UNGROUPING A RVA.\"; WRITELN \"AS TO WHY THE ATTRIBUTES WERE WRAPPED HERE AND NOT SOONER (SHRUG) :-).\";"}, TUPLE {Name "Expression115919", Definition "WRITELN \"THIS ENDS THE OPERATIONS TO GET A DE-NORMALIZED RELATION COVERING ALL THE SPLITTING BY THE 5 DELIMITERS.\"; WRITELN \"THE NEXT PHASE IS TO RECONSTITUTE THIS RELATION TO SHOW THE SAME INFORMATION NORMALIZED.\"; WRITELN \"WE WANT TO SHOW ALL SPLITTING USING ATTRIBUTES CTK, SPLIT#, KEY. (ALL NUMS#\'S WILL BE RENAMED KEY.) AND str.\"; WRITELN \"AND IT SHOULD COME AS NO SURPRISE THAT WE\'LL BE USING RELATIONS TO ACCOMPLISH THIS.\"; "}, TUPLE {Name "Expression116204", Definition "WRITELN \"WE START WITH THE GROUP OPERATOR. I WOULD COMPARE GROUP TO REGULAR EXPRESSIONS. IF YOU KNOW HOW TO USE GROUP IT\'S THE OPERATOR FROM HEAVEN, IF YOU DON\'T AND USE IT THEN IT\'S THE OPERATOR FROM HELL:-). \"; WRITELN \"GROUP CAN RESTRUCTURE A RELATION BY ITSELF. BRIEFLY, THE INTENT IS TO CREATE NAMED RVA\'S (RELATIONAL VALUED ATTRIBUTES) WITH ATTRIBUTE(S) YOU SPECIFY WHERE THE NUMBER OF RVA\'S CREATED IS BASED ON THE VALUES OF THE REMAINING ATTRIBUTES (OTHER THAN THE ONES SPECIFIED) IN THE OVERALL RELATION.\"; WRITELN \"IF THE NUMBER OF NON-SPECIFIED ATTRIBUTE(S) HAVE MANY UNIQUE VALUES THEN THERE WILL BE MANY RVA\'S CREATED. IF THE NON-SPECIFIED ATTRIBUTE(S) HAVE MANY DUPLICATES THEN THERE WILL BE A LOW NUMBER OF RVA\'S CREATED.\"; WRITELN \"A DE-NORMALIZED RELATION LIKE THIS HAS MOSTLY UNIQUE VALUES AND RELATIONS CREATED BY GROUP WILL REFLECT THIS.\"; WRITELN \"LATER ON IN THE QUERY, GROUP WILL BE USED AGAIN WHERE THE OVERALL RELATION WILL HAVE FEWER ATTRIBUTES AND IT WILL BE EASIER TO SEE THE EFFECT OF GROUP AND HOW IT WORKS.\"; "}, TUPLE {Name "Expression116961", Definition "WRITELN \"HERE WE START TURNING ALL THE ATTRIBUTES FOR EACH SPLIT (1-5) INTO A RVA (RELATIONAL VALUED ATTRIBUTE) BECAUSE WE ONLY WANT TO MANIPULATE RELATIONS INSTEAD OF ISOLATED ATTRIBUTES.\"; WRITELN \"THE GROUP OPERATION IS USED TO CREATE 5 RVA\'S (GRP1-GRP5) EACH CORRESPONDING TO THE ATTRIBUTES OF SPLITTING BY A PARTICULAR DELIMITER.\"; WRITELN \"THE ATTRIBUTES FOR THE 1ST SPLIT ARE CTK1, SPLIT#1, NUMS#1 AND str1. WE CALL THE RVA GRP1. THE ATTRIBUTES FOR THE 2ND SPLIT ARE CTK2, SPLIT#2, NUMS#2 AND str2. WE CALL THAT RVA GRP2.\"; WRITELN \"THIS PROCESS IS REPEATED UNTIL WE HAVE RVA\'S GRP1-GRP5. THE IMPORTANT THING TO NOTE IS THAT EACH TUPLE IN THE OVERALL RELATION NOW HAS RVA\'S GRP1-GRP5 CONTAINING THE SAME\"; WRITELN \"INFORMATION PREVIOUSLY BUT NOW WE CAN WORK WITH THIS INFORMATION IN THE FORM OF RELATIONS. BUT AT THIS POINT NOTE THAT THE OVERALL RELATION IS STILL DE-NORMALIZED\"; "}, TUPLE {Name "Expression117656", Definition "WRITELN \"HERE WE PERFORM ANOTHER STEP TOWARDS THE GOAL OF NORMALIZATION. WE TAKE EVERY RVA (GRP1-GRP5) AND CREATE NEW RVA\'S WHICH ARE EXACTLY THE SAME ATTRIBUTE VALUES BUT SHARE THE SAME NAME FOR EACH ATTRIBUTE.\"; WRITELN \"SO FOR EVERY CTK(1-5) WE NAME IT JUST CTK, FOR EVERY SPLIT#(1-5) WE NAME IT JUST SPLIT#, FOR EVERY NUMS#(1-5) WE NAME KEY. AND FOR EVERY str(1-5) WE NAME IT JUST str.\"; WRITELN \"THE NEW RVA NAMES ALL START WITH THE LETTER \'U\' BECAUSE WE INTEND TO USE THEM IN A UNION OPERATION.\"; WRITELN \"NOTE THAT EACH RENAME STARTS WITH WORD \'SUFFIX\' AND A NUMBER IN QUOTES. THIS IS A SHORTHAND YOU CAN USE IN RENAME.\"; WRITELN \"FOR NEW RVA U.GRP1, GRP1 RENAME {SUFFIX \'1\' AS \'\'} RENAME {NUMS# AS KEY.} IS THE SHORTHAND FOR GRP1 RENAME {CTK1 AS CTK,SPLIT#1 AS SPLIT#,NUMS#1 AS KEY.,str1 AS str}. IT JUST MEANS USE THE NAME OF THE ATTRIBUTE EXCEPT THE PARTICULAR NUMBER THE ATTRIBUTE ENDS IN FOR THE NEW NAME. BUT THIS MEANS NUMS#1 WILL THEN BE RENAMED NUMS# SO TO GET KEY. ANOTHER RENAME HAS FOLLOW TO GET KEY., IE. RENAME {NUMS# AS KEY.}.\";WRITELN \"ALSO NOTE THAT WHEN RVA\'S ARE CREATED WITH AN EXTEND OPERATION THE SAME ATTRIBUTE NAMES CAN BE USED IN DIFFERENT RVA\'S. THIS BECAUSE IN THIS CONTEXT ATTRIBUTES IN ONE RVA ARE ISOLATED/OUT OF SCOPE TO ATTRIBUTES IN ANOTHER RVA.\";"}, TUPLE {Name "Expression119242", Definition "WRITELN \"WE\'RE FINALLY AT THE POINT WHERE WE CAN REPRESENT SPLITTING BY ALL 5 DELIMITERS IN A NORMALIZED WAY. THE EXTEND OPERATOR IS USED\"; WRITELN \"TO CREATE ANOTHER RVA NAMED UNION.U.GRPS THAT UNIONS TOGEHER THE 5 U.GRP RELATIONS (U.GRP1-U.GRP5) IN EACH TUPLE. BECAUSE EACH TUPLE IN THE\"; WRITELN \"OVERALL RELATION IS EXTENDED INDIVIDUALLY THERE IS NEVER THE POSSIBILITY THAT ANY U.GRP RVA CAN COME FROM ANY TUPLE OTHER\"; WRITELN \"THAN THE PARTICULAR OVERALL RELATION TUPLE BEING PROCESSED.\";"}, TUPLE {Name "Expression119811", Definition "WRITELN \"THIS Project OPERATION ALTERS THE CURRENT OVERALL RELATION BY KEEPING ONLY THE PARTICULAR ATTRIBUTES THAT ARE RELEVANT FROM THIS TIME FORWARD.\"; WRITELN \"OR, IF YOU WILL, REMOVES THE ATTRIBUTES THAT ARE NO LONGER RELEVANT ALTHOUGH THERE IS AN \'ALL BUT\' VERSION OF Project THAT ALLOWS YOU TO DIRECTLY\"; WRITELN \"SPECIFY THE ATTRIBUTES YOU WANT REMOVED.\";"}, TUPLE {Name "Expression120304", Definition "WRITELN \"SHORTLY THE OVERALL RELATION WILL BE RESTRUCTURED AGAIN AND FOR THAT WE NEED THE OVERALL RELATION TO CONSIST OF JUST ATTRIBUTES\"; WRITELN \"SO THE RVA UNION.U.GRPS IS UNGROUPED TRANSFORMING THE RVA IN EACH TUPLE TO ATTRIBUTES CTK, SPLIT#, KEY. AND str.\"; WRITELN \"NOTE THAT, AS ALWAYS, ATTRIBUTE KEY. HAS A UNIQUE VALUE SO NO INFORMATION IS LOST BY THE UNGROUP.\";"}, TUPLE {Name "Expression120305", Definition "WRITELN \"THIS IS THE Project OPERATOR THAT HAS A PROBLEM MENTIONED AT THE BEGINNING OF THE QUERY. IF THE CORRECTION OUTLINED ABOVE\"; WRITELN \"WAS/IS MADE YOU CAN CLICK ON IT TO SEE THE QUERY. IF YOU HAVEN\'T MADE THE CORRECTION DON\'T WORRY. THE Project WILL STILL BE\"; WRITELN \"IN EFFECT AND THE REST OF THE QUERY WILL WORK. THIS Project ELIMINATES ATTRIBUTE CTK FROM THE OVERALL RELATION BECAUSE IT WILL\"; WRITELN \"NOT BE NEEDED AND WILL BE REPLACED WITH ANOTHER COUNTER. FROM A DOCUMENTATION STANDPOINT, IT MAY BE MORE APPROPRIATE\"; WRITELN \"TO DISPLAY THE ATTRIBUTES STILL DESIRED IN THE RELATION THAN THE ATTRIBUTE(S) YOU WANT ELIMINATED. AND AGAIN BECAUSE KEY. IS\"; WRITELN \"UNIQUE ELIMINATING ATTRIBUTE CTK DOES NOT LEAD TO ANY LOSS (LOSING TUPLES IN THE OVERALL RELATION) OF INFORMATION.\";"}, TUPLE {Name "Expression123736", Definition "WRITELN \"AS MENTIONED PREVIOUSLY GROUP RESTRUCTURES THE OVERALL RELATION BY CREATING A NAMED RVA (RELATION VALUE ATTRIBUTE) WHOSE ATTRIBUTE(S)\"; WRITELN \"ARE CURRENTLY ATTRIBUTE(S) IN THE OVERALL QUERY AND THAT YOU SPECIFY. THE ATTRIBUTE(S) THAT ARE IN THE OVERALL RELATION THAT AREN\'T\"; WRITELN \"SPECIFIED ARE GROUPED BY THEIR VALUES AND THE DIFFERENT GROUPS FORMED HAVE THE SPECIFIED ATTRIBUTE(S) IN THE RVA.\"; WRITELN \"HERE ATTRIBUTES SPLIT# AND KEY. ARE THE ATTRIBUTES IN THE RVA NAMED GRP.STRINGS. THE ATTRIBUTES THAT FORM THE GROUPS ARE\"; WRITELN \"ID, INPUT.STR, WRAPattr AND MOST IMPORTANTLY str. AS YOU CAN SEE THE UNIQUE GROUPS FORMED BY THESE 4 ATTRIBUTES HAVE THEIR\"; WRITELN \"CORRESPONDING ATTRIBUTES OF SPLIT# AND KEY. AS TUPLES IN THE RVA. THE GROUP OPERATOR SHARES SIMILARITIES WITH THE SQL\"; WRITELN \"GROUP BY OPERATION. BUT WITH GROUP THE GROUPING ATTRIBUTES ARE IMPLIED WHERE IN SQL GROUP BY THEY\'RE EXACTLY SPECIFIED.\"; WRITELN \"THE SQL GROUP BY TAKES AN AGGREGATE FUNCTION(S) AS ITS ARGUMENT WHILE GROUP TAKES ATTRIBUTE(S).\";"}, TUPLE {Name "Expression124419", Definition "WRITELN \"AS YOU CAN SEE EVERY STRING (ATTRIBUTE str WITHIN AN ID/INPUT.STR) THAT WAS THE RESULT OF A SPLITTING OPERATION IS SHOWN AS AN ATTRIBUTE\"; WRITELN \"AND INSIDE THE RELATIONAL VALUED ATTRIBUTE GRP.STRINGS ARE THE TUPLES THAT SHOW THE PARTICULAR SPLITTING OPERATION(S) THAT\"; WRITELN \"str WAS INVOLVED IN (SPLIT#) AND AN INTEGER THAT REPRESENTS THE STRINGS SPLIT OCCURRANCE(S) RELATIVE TO THE STRINGS\"; WRITELN \"PLACE IN ITS CORRESPONDING INPUT.STR/ID (KEY.). (THE MEANING OF KEY. IN THIS SENSE WILL BECOME CLEARER LATER ON).. THE REASON\"; WRITELN \"FOR USING THIS GROUP OPERATION WILL ALSO BE CLEARER AS WE MOVE ON.\";"}, TUPLE {Name "Expression124747", Definition "WRITELN \"AS YOU CAN SEE MANY STRINGS (str) ARE SPLIT BY DELIMITER 5. SOME STRINGS ARE SPLIT BY A PARTICULAR DELIMITER AND DO NOT\"; WRITELN \"APPEAR AGAIN. OBVIOUSLY SUCH STRINGS HAVE OTHER DELIMITER(S) IN THEM AND THOSE STRINGS CAN EITHER BE MAXIMALLY SPLIT\"; WRITELN \"(HAVE NO OTHER DELIMITER(S) IN THEM) AND CONTINUE ON TO SPLIT#5 OR HAVE DELIMITER(S) IN THEM AND ARE SUBSEQUENTLY SPLIT.\"; WRITELN \"OF COURSE THIS IS THE PROCESS OF SPLITTING STRINGS :-). NOTE, AS MENTIONED PREVIOUSLY, EVEN IF A STRING HAS NO DELIMITER(S)\"; WRITELN \"IN IT THERE WILL STILL BE AN ATTEMPT TO SPLIT IT BY THE NEXT DELIMITER. IN SUCH CASES THE SPLIT OPERATION WILL JUST RETURN\"; WRITELN \"THE STRING ITSELF. NO ATTEMPT IS MADE TO STOP A STRING FROM CONTINUING THE SPLITTING PROCESS BECAUSE IT HAS NO DELIMITER(S)\"; WRITELN \"(YOU WILL SEE THIS AS AN OPTION IN OPERATOR SPLITREL.NEST). FOR THIS REASON YOU CAN SEE STRINGS THAT WERE MAXIMALLY SPLIT\"; WRITELN \"WITH DELIMITER 1 HAVE 5 TUPLES (SPLIT#\'S 1-5) IN RVA GRP.STRINGS. FOR OTHER STRINGS IT WASN\'T UNTIL DELIMITER 5 THAT THEY\"; WRITELN \"WERE SPLIT MAXIMALLY SO THEREFORE THEY ONLY HAVE 1 TUPLE IN RVA GRP.STRINGS.\"; "}, TUPLE {Name "Expression124748", Definition "WRITELN \"IN THIS QUERY WE WANT TO RETURN ONLY THOSE STRINGS IN EACH INPUT.STR (ID) THAT ARE DELIMITERED. SUCH STRINGS HAVE BEEN REFERRED TO\"; WRITELN \"AS MAXIMALLY SPLIT STRINGS BECAUSE THEY HAVE NO DELIMITER(S) IN THEM. PLACING THIS RESTRICTION ON THE STRINGS TO BE RETURNED CAN BE\"; WRITELN \"ACCOMPLISHED IN A NUMBER OF WAYS. TO RETURN THE TUPLES OF THE QUERY WITH A str THAT IS MAXIMALLY SPLIT WE\'RE GOING TO USE\"; WRITELN \"RVA GRP.STRINGS. WE COULD CHECK THAT EACH str DOESN\'T HAVE ANY OF THE DELIMITERS BUT INSTEAD WE CAN LOOK INTO THE RVA AND\"; WRITELN \"CHECK THAT ATTRIBUTE SPLIT# EXISTS WITH A VALUE OF 5. ONLY STRINGS THAT HAVE BEEN SPLIT BY DELIMITER 5 ARE MAXIMALLY SPLIT STRINGS. FOR NOW DON\'T\"; WRITELN \"WORRY ABOUT THE DETAILS OF THE RESTRICTION, JUST SEE THAT IT DOES WHAT IT SHOULD :-). BUT DO NOTE THAT A RESTRICTION OPERATION IS ANY\";WRITELN \"EXPRESSION, REGARDLESS OF HOW COMPLEX, THAT EVALUATES TO A BOOLEAN VALUE, IE. EITHER TRUE OR FALSE.\";"}, TUPLE {Name "Expression125033", Definition "WRITELN \"BECAUSE WE\'LL NEED THEM THE DELIMITER ATTRIBUTES SDEL1-SDEL5 WRAPPED IN TVA (TUPLE VALUED ATTRIBUTE) WRAPattr ARE NOW EXPOSED\";WRITELN \"IN THE OVERALL RELATION AS INDIVIDUAL ATTRIBUTES IN EACH TUPLE OF THE OVERALL RELATION BY USING THE UNWRAP OPERATION.\";"}, TUPLE {Name "Expression125400", Definition "WRITELN \"WE ARE GOING TO NEED TO DEFINE A RELATION THAT STORES THE DELIMITERS (SDEL1-SDEL5) AND THE SEQUENCE OF SPLITTING. THE SEQUENCE\"; WRITELN \"CORRESPONDS TO WHAT WE ARE USING ATTRIBUTE SPLIT# IN RVA GRP.STRINGS FOR. EACH TUPLE IN THE RELATION HAS AN ATTRIBUTE\"; WRITELN \"DEL (SHORT FOR DELIMITER) AND ATTRIBUTE M1 WHICH STORES AN INTEGER INDICATING THE PARTICULAR SPLIT (1-5) THAT DEL WAS USED FOR.\"; WRITELN \"THE RELATION WILL BE AN RVA NAMED DELS THAT WILL BE ADDED TO EACH TUPLE IN THE OVERALL RELATION USING AN EXTEND OPERATION.\"; WRITELN \"THIS IS WHY TVA WRAPattr WAS UNWRAPPED SO THE INDIVIDUAL ATTRIBUTES SDEL1-SDEL5 (AND OBVIOUSLY THEIR VALUES) ARE AVAILABLE\"; WRITELN \"IN RVA DELS. THIS IS ADMITTINGLY QUITE INEFFICIENT AND IN ACTUAL PRACTICE YOU WOULD DO SOMETHING FAR MORE EFFICIENT THAN\"; WRITELN \"STORING EACH DELIMITER IN THE OVERALL RELATION AS WELL AS A RELATION WITH THEM. BUT FOR THE PURPOSE OF USING THIS INFORMATION\"; WRITELN \"WITHIN A Rev QUERY (AND NOT STORING THIS DATA INDEPENDENTLY ELSEWHERE IN THE DATABASE) IT WILL DUE :-).\";"}, TUPLE {Name "Expression128340", Definition "WRITELN \"FOR THE STRINGS (str) REMAINING IN THE OVERALL RELATION WE WANT TO DISPLAY THE DELIMITER (SDEL1-SDEL5) AND ITS CORRESPONDING SPLIT# THAT\"; WRITELN \"WAS RESPONSIBLE FOR THE STRING. GIVEN THAT ALL STRINGS REMAINING IN THE OVERALL RELATION ARE MAXIMALLY SPLIT AND A STRING CAN HAVE AS MANY\"; WRITELN \"AS 5 DELIMITERS PRESENT IN RVA GRP.STRINGS, WE WANT THE 1ST DELIMITER USED THAT CREATED THE STRING. AN EXTEND OPERATION IS USED TO ADD ATTRIBUTE\"; WRITELN \"SPLIT.N WHERE SPLIT.N IS COMPUTED AS THE MINIMUM SPLIT# IN RVA GRP.STRINGS. NEXT ATTRIBUTE LEVEL IS DEFINED AND USES THE VALUE OF SPLIT.N TO SHOW\"; WRITELN \"THE SPLIT# THAT FIRST CREATED THE STRING AND ALSO USES SPLIT.N TO FIND THE DELIMITER (IN RVA DELS) THAT CORRESPONDS TO THE SPLIT#. ATTRIBUTE LEVEL\"; WRITELN \"IS BASED ON A USER-DEFINED TYPE (ALSO NAMED LEVEL) THAT DISPLAYS BOTH PIECES OF INFORMATION (THIS IS THE SAME TYPE LEVEL USED IN OPERATOR SPLITREL.NEST\"; WRITELN \"AND YOU WILL SEE MUCH MORE OF IT IN THAT OPERATOR).\";"}, TUPLE {Name "Expression128341", Definition "WRITELN \"FINALLY ATTRIBUTE KEY. IS DEFINED (THE NAME KEY. CAN BE USED FOR AN ATTRIBUTE OF THE OVERALL RELATION EVEN THOUGH THE SAME NAME IS USED IN RVA GRP.STRINGS\"; WRITELN \"BECAUSE THE ATTRIBUTE NAMES IN GRP.STRINGS ARE OUT OF SCOPE TO THE ATTRIBUTES NAMES IN THE OVERALL RELATION) AND IT INDICATES THE SEQUENCE THAT STRINGS\"; WRITELN \"WERE ENCOUNTERED (AND SPLIT) IN ATTRIBUTE INPUT.STR. IT IS BASED ON THE MAXIMUM VALUE OF KEY. IN RVA GRP.STRINGS FOR EACH str WHICH CORRESPONDS TO SPLIT# 5.\"; WRITELN \"BUT IN FACT ANY OF THE KEY. VALUES IN GRP.STRINGS WOULD SUFFICE. ALL THE KEY. VALUES IN GRP.STRINGS FOR A str ARE INDICATIVE OF WHERE THE str IS IN INPUT.STR AND\"; WRITELN \"THESE KEY. VALUES DO NOT OVERLAP WITH THE KEY. VALUES OF ANY OTHER str. THAT\'S WHY ANY OF THE KEY. VALUES COULD BE USED. UNFORTUNATELY THE SITUATION WITH\"; WRITELN \"KEY. VALUES IN GRP.STRINGS GETS MORE COMPLEX WHEN DUPLICATE STRINGS EXIST IN AN INPUT.STR. TO SIMPLIFY THIS Rev QUERY AND GET CORRECT RESULTS USE ONLY\"; WRITELN \"UNIQUE DELIMITED STRINGS IN INPUT.STR.\"; WRITELN \"NEW ATTRIBUTE KEY. WILL BE USED TO COMPUTE RANKS FOR THE STRINGS (str) FOR EACH ID.\";"}, TUPLE {Name "Expression128662", Definition "WRITELN \"THIS FORM OF Project USES \'ALL BUT\' TO LIST ALL THE ATTRIBUTES OF THE OVERALL RELATION TO BE REMOVED. WE NO LONGER NEED ANY\";WRITELN \"OF THESE ATTRIBUTES. THE ONLY ATTRIBUTES OF INTEREST NOW ARE ID, INPUT.STR, str, KEY., AND LEVEL .\";"}, TUPLE {Name "Expression129727", Definition "WRITELN \"IF WE WANTED TO PROCEDURALLY RANK THE SEQUENCE OF SPLITTING IN EACH INPUT.STR WE COULD START WITH SOME KIND OF LOOP THAT\"; WRITELN \"ISOLATES THE DATA FOR EACH ID AND THEN GET THE RANKS FOR str FOR THAT PARTICULAR ID. THE OPERATION OF ISOLATING THE DATA FOR\"; WRITELN \"FOR EACH ID/INPUT.STR IS EXACTLY WHAT THE GROUP OPERATOR DOES BUT WE\'RE DOING IT DECLARATIVELY USING RELATIONAL ALGEBRA INSTEAD\"; WRITELN \"OF PROCEDURALLY. THIS GROUP OPERATION RECONSTRUCTS THE OVERALL RELATION SO THERE ARE ONLY AS MANY TUPLES IN THE OVERALL RELATION\"; WRITELN \"AS THERE ARE ID\'S. THE RVA GRPS, WITH ATTRIBUTES str, LEVEL, AND KEY., IS THE \'ISOLATED\' DATA FOR EACH ID/INPUT.STR. NOW WE HAVE ONLY TO APPLY\"; WRITELN \"THE RANK OPERATION TO EACH RVA GRPS TO HAVE THE RANKS FOR str FOR EACH ID/INPUT.STR.\";"}, TUPLE {Name "Expression130117", Definition "WRITELN \"FOR RANKING str AN EXTEND OPERATION SEEMS LIKE WHAT WE NEED TO USE BUT WHAT FORM DOES IT TAKE? BECAUSE RVA GRPS IS NOT DIRECTLY IN\"; WRITELN \"SCOPE WE NEED A BRIDGE BETWEEN THE OVERALL RELATION AND RVA GRPS THAT WILL CONNECT THE TWO. THAT BRIDGE IS ANOTHER RELATION WHICH\"; WRITELN \"WILL BE A RVA. WE NAME THIS RVA RANKS. RELATION RANKS ALLOWS RVA GRPS TO BE PUT IN SCOPE, IE. IT ALLOWS US TO ACCESS IT FOR EACH TUPLE IN\"; WRITELN \"THE OVERALL RELATION AND TO WHICH THE RANK OPERATION CAN BE APPLIED SEPARATELY TO EACH RVA GRP. THE RANKING IS BASED ON ATTRIBUTE\"; WRITELN \"KEY. (WITHIN RVA GRPS) WHICH ASCENDS IN THE ORDER THE STRINGS WERE SPLIT WITHIN ITS ID. SINCE THIS OPERATION IS DONE FOR IDS SEPARATELY\"; WRITELN \"WE ARE GUARANTEED THE RANKS WILL START AT 1 FOR EACH ID. IF RANKING WERE APPLIED TO JUST THE OVERALL RELATION THERE IS NO WAY TO SPECIFY\"; WRITELN \"THE RANKS SHOULD RESTART AT 1 FOR A NEW ID (TECHNICALLY THERE IS SUCH A WAY BUT IT\'S MORE COMPLEX (AND NOT NECESSARY FOR THE PURPOSE\"; WRITELN \"AT HAND) THAN THE STRAIGHTWARD WAY BEING SHOWN). LASTLY, IN THE RANK SPECIFICATION THE \'AS CTK\' IS USED TO DECLARE THE NAME OF THE\"; WRITELN \"ATTRIBUTE THAT WILL HOLD THE RANKS. HERE ATTRIBUTE CTK WILL HOLD THE RANK FOR EACH str.\"; "}, TUPLE {Name "Expression130312", Definition "WRITELN \"ATTRIBUTE (RVA) GRPS IS NO LONGER NEEDED IN THE OVERALL RELATION SO A Project OPERATION IS USED TO KEEP ONLY THE RELEVANT\";WRITELN \"ATTRIBUTES WHICH ARE ID, INPUT.STR AND RVA RANKS.\";"}, TUPLE {Name "Expression130597", Definition "WRITELN \"TO VIEW THE OVERALL RELATION WITH JUST SCALAR ATTRIBUTES RVA RANKS IS UNGROUPED.\";"}, TUPLE {Name "Expression79846", Definition "REL{ TUP{ID 2,INPUT.STR \"A,A,C,C,D&10&10$20@30@40@30&A&C\"},TUP{ID 3,INPUT.STR \"R,S,R,T&50&60#70#80\"}}"}, TUPLE {Name "Expression87323copy", Definition "REL{TUP{ID 2,INPUT.STR \"R,S,T*50*60$M$H#70#80$Q@END\"},TUP{ID 3,INPUT.STR \"A,B,C,D*10*25$20@30@40@5,A15#FC$END\"}}"}, TUPLE {Name "GROUP82528", Definition "{LEVEL5, str5, KEY5} AS GROUPattr"}, TUPLE {Name "GROUP89363copy", Definition "{CTK1, str1, SPLIT#1, NUMS#1} AS GRP1"}, TUPLE {Name "GROUP89528copy", Definition "{CTK2, str2, SPLIT#2, NUMS#2} AS GRP2"}, TUPLE {Name "GROUP89611copy", Definition "{CTK3, str3, SPLIT#3, NUMS#3} AS GRP3"}, TUPLE {Name "GROUP89694copy", Definition "{CTK4, str4, SPLIT#4, NUMS#4} AS GRP4"}, TUPLE {Name "GROUP89777copy", Definition "{CTK5, str5, SPLIT#5, NUMS#5} AS GRP5"}, TUPLE {Name "GROUP91497copy", Definition "{SPLIT#, KEY.} AS GRP.STRINGS"}, TUPLE {Name "GROUP92574copy", Definition "{str, LEVEL, KEY.} AS GRPS"}, TUPLE {Name "Project80020", Definition "{ID, str, N.SPLIT, KEY., SPLIT2, INPUT.STR}"}, TUPLE {Name "Project80352", Definition "{ID, str, KEY., SPLIT3, LEVEL.N, INPUT.STR}"}, TUPLE {Name "Project80602", Definition "{ID, str, KEY., SPLIT4, LEVEL.N, INPUT.STR}"}, TUPLE {Name "Project81538", Definition "{ID, str, KEY., SPLIT5, LEVEL.N, INPUT.STR}"}, TUPLE {Name "Project81788", Definition "{ID, str, KEY., LEVEL5, INPUT.STR}"}, TUPLE {Name "Project83205", Definition "{ID, RANKS, INPUT.STR}"}, TUPLE {Name "Project87492copy", Definition "{ALL BUT SPLIT1}"}, TUPLE {Name "Project87667copy", Definition "{ALL BUT SPLIT2}"}, TUPLE {Name "Project87918copy", Definition "{ALL BUT SPLIT3}"}, TUPLE {Name "Project88276copy", Definition "{ALL BUT SPLIT4}"}, TUPLE {Name "Project91084copy", Definition "{ID, INPUT.STR, WRAPattr, UNION.U.GRPS}"}, TUPLE {Name "Project91414copy", Definition "{ID, INPUT.STR, WRAPattr, str, SPLIT#, KEY.}"}, TUPLE {Name "Project92326copy", Definition "{ALL BUT SDEL1, SDEL2, SDEL3, SDEL4, SDEL5, DELS, SPLIT.N, GRP.STRINGS}"}, TUPLE {Name "Project92658copy", Definition "{ID, INPUT.STR, RANKS}"}, TUPLE {Name "RENAME80103", Definition "str AS PREV.str, N.SPLIT AS PREV.LEVEL.N, KEY. AS PREV.KEY"}, TUPLE {Name "RENAME80435", Definition "str AS PREV.str, KEY. AS PREV.KEY, LEVEL.N AS PREV.LEVEL.N"}, TUPLE {Name "RENAME80685", Definition "str AS PREV.str, KEY. AS PREV.KEY, LEVEL.N AS PREV.LEVEL.N"}, TUPLE {Name "RENAME81621", Definition "str AS PREV.str, KEY. AS PREV.KEY, LEVEL.N AS PREV.LEVEL.N"}, TUPLE {Name "RENAME81871", Definition "str AS str5, KEY. AS KEY5"}, TUPLE {Name "Restrict91662copy", Definition "(NOT IS_EMPTY(GRP.STRINGS MATCHING REL{TUP{SPLIT# 5}}))"}, TUPLE {Name "UNGROUP87435copy", Definition "R1"}, TUPLE {Name "UNGROUP87568copy", Definition "R2"}, TUPLE {Name "UNGROUP87767copy", Definition "R3"}, TUPLE {Name "UNGROUP88069copy", Definition "R4"}, TUPLE {Name "UNGROUP92823copy", Definition "RANKS"}, TUPLE {Name "UNWRAP91745copy", Definition "WRAPattr"}, TUPLE {Name "WRAP88476copy", Definition "{SDEL1, SDEL2, SDEL3, SDEL4, SDEL5} AS WRAPattr"} } ; //VAR sys.rev.Op_Extend REAL RELATION {Name CHARACTER, Definition RELATION {ID INTEGER, attribute CHARACTER, expression CHARACTER}} KEY {Name}; sys.rev.Op_Extend := RELATION {Name CHARACTER, Definition RELATION {ID INTEGER, attribute CHARACTER, expression CHARACTER}} { TUPLE {Name "EXTEND79851", Definition RELATION {ID INTEGER, attribute CHARACTER, expression CHARACTER} { TUPLE {ID 0, attribute "SPLIT1", expression "Rel.SPLIT(INPUT.STR,BRACKET.DELIMITER(\",\",LENGTH(\",\")),FALSE) EXTEND {IDX:=ID,N.SPLIT:=1,KEY.:=GET_UNIQUE_NUMBER()"}, TUPLE {ID 1, attribute "SPLIT2", expression "Rel.SPLIT(str,BRACKET.DELIMITER(\"&\",LENGTH(\"&\")),FALSE) EXTEND {IDX:=ID,N.SPLIT:=2,KEY.:=GET_UNIQUE_NUMBER()"}, TUPLE {ID 2, attribute "SPLIT3", expression "Rel.SPLIT(str,BRACKET.DELIMITER(\"$\",LENGTH(\"$\")),FALSE) EXTEND {IDX:=ID,N.SPLIT:=3,KEY.:=GET_UNIQUE_NUMBER()"}, TUPLE {ID 3, attribute "SPLIT4", expression "Rel.SPLIT(str,BRACKET.DELIMITER(\"@\",LENGTH(\"@\")),FALSE) EXTEND {IDX:=ID,N.SPLIT:=4,KEY.:=GET_UNIQUE_NUMBER()"}, TUPLE {ID 4, attribute "SPLIT5", expression "Rel.SPLIT(str,BRACKET.DELIMITER(\"#\",LENGTH(\"#\")),FALSE) EXTEND {IDX:=ID,N.SPLIT:=5,KEY.:=GET_UNIQUE_NUMBER() } } } } }"} }}, TUPLE {Name "EXTEND80351", Definition RELATION {ID INTEGER, attribute CHARACTER, expression CHARACTER} { TUPLE {ID 0, attribute "LEVEL.N", expression "IF (LENGTH(str)