#This file is part of SECONDO.
#
#Copyright (C) 2004, University in Hagen, Department of Computer Science,
#Database Systems for New Applications.
#
#SECONDO is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#
#SECONDO is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#GNU General Public License for more details.
#
#You should have received a copy of the GNU General Public License
#along with SECONDO; if not, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

# a test for the relational algebra
# run with : Runner -c MyConfig.config <relalgtest
# (Runner can be found in directory UserInterfaces)

# clean up what may be left over from e.g. a segfault
delete database relalgtest;

#setup
create database relalgtest;
open database relalgtest;

(create empty : (rel(tuple((No int)))));
(update empty := ((rel(tuple((No int))))()));

(create two : (rel(tuple((No int)))));
(update two := ((rel(tuple((No int))))((1)(2))));

(create three : (rel(tuple((No int)))));
(update three := ((rel(tuple((No int))))((1)(1)(1))));

(create ten : (rel(tuple((No int)))));
(update ten := ((rel(tuple((No int))))((1)(2)(3)(4)(5)(6)(7)(8)(9)(10))));

(create twenty : (rel(tuple((No int)))));
(update twenty := ((rel(tuple((No int))))((1)(2)(3)(4)(5)(6)(7)(8)(9)(10)(11)(12)(13)(14)(15)(16)(17)(18)(19)(20))));

(create even : (rel(tuple((No int)))));
(update even := ((rel(tuple((No int))))((2)(4)(6)(8)(10)(12)(14)(16)(18)(20))));

(create odd : (rel(tuple((No int)))));
(update odd := ((rel(tuple((No int))))((1)(3)(5)(7)(9)(11)(13)(15)(17)(19))));

(create duplicates : (rel(tuple((No int)))));
(update duplicates := ((rel(tuple((No int))))((1)(1)(1)(6)(6)(7)(9)(9)(9)(9))));

(create real : (rel(tuple((No real)))));
(update real := ((rel(tuple((No real))))((1.0)(3.0)(-6.0)(7.0)(9.0)(0.875)(-9.875)(-23.625))));

(create Employee :
	(rel
                (tuple
                    (
                        (EName string)
                        (EmpNr int)
                        (DeptNr int)))));

(update Employee :=
	((rel
                (tuple
                    (
                        (EName string)
                        (EmpNr int)
                        (DeptNr int))))
		(
                ("Smith" 12 3)
                ("Myers" 13 2)
                ("Bush" 11 1)
                ("Jones" 14 2)
                ("Smith" 16 1)
                ("Langdon" 9 3)
                ("Lambert" 4 3)
                ("Callahan" 1 2)
                ("Myers" 17 2)
                ("Simpson" 8 3))));

(create Dept : (rel
                (tuple
                    (
                        (Leader string)
                        (DeptNr int)))));

(update Dept := ((rel
                (tuple
                    (
                        (Leader string)
                        (DeptNr int))))
            (
                ("Smith" 3)
                ("Myers" 2)
                ("Bush" 1))));


(create Staedte : (rel
                    (tuple
                      (
                        (SName string)
                        (Bev int)
                        (PLZ int)
                        (Vorwahl text)
                        (Kennzeichen string)))));



(update Staedte := ((rel
                (tuple
                    (
                        (SName string)
                        (Bev int)
                        (PLZ int)
                        (Vorwahl text)
                        (Kennzeichen string))))
            (
                ("Aachen" 239000 5100 '242387399811123125657234' "AC")
                ("Berlin" 1859000 1000 '300023486212512398734' "B")
                ("Bielefeld" 300000 4800 '522387399811123125657234' "BI")
                ("Bochum" 382000 4630 '2343948729384787' "BO")
                ("Bonn" 291000 5300 '2282938742983472387878' "BN")
                ("Braunschweig" 248000 3300 '532387399811123125657234' "BS")
                ("Bremen" 526000 2800 '422387399811123125657234' "HB")
                ("Bremerhaven" 134000 2850 '472387399811123125657234' "HB")
                ("Darmstadt" 134000 6100 '6152387399811123125657234' "DA")
                ("Dortmund" 572000 4600 '232387399811123125657234' "DO")
                ("Duesseldorf" 562000 4000 '212387399811123125657234' "D")
                ("Duisburg" 518000 4100 '20323746283746' "DU")
                ("Erlangen" 100000 8520 '9132387399811123125657234' "ER")
                ("Essen" 620000 4300 '202387399811123125657234' "E")
                ("Frankfurt(Main)" 595000 6000 '6298347402394810489134' "F")
                ("Freiburg" 184000 7800 '762387399811123125657234' "FR")
                ("Gelsenkirchen" 285000 4650 '20298347402394810489134' "GE")
                ("Goettingen" 133000 3400 '552387399811123125657234' "GOE")
                ("Hagen" 206000 5800 '2332387399811123125657234' "HA")
                ("Hamburg" 1580000 2000 '400023486212512398734' "HH")
                ("Hamm" 166000 4700 '2382387399811123125657234' "HAM")
                ("Hannover" 508000 3000 '512387399811123125657234' "H")
                ("Heidelberg" 135000 6900 '6222387399811123125657234' "HD")
                ("Heilbronn" 111000 7100 '7132387399811123125657234' "HN")
                ("Hildesheim" 101000 3200 '5122387399811123125657234' "HI")
                ("Karlsruhe" 268000 7500 '722387399811123125657234' "KA")
                ("Kassel" 184000 3500 '562387399811123125657234' "KS")
                ("Kiel" 246000 2300 '432387399811123125657234' "KI")
                ("Koblenz" 111000 5400 '262387399811123125657234' "KO")
                ("Koeln" 916000 5000 '222387399811123125657234' "K")
                ("Krefeld" 217000 4150 '2152387399811123125657234' "KR")
                ("Leverkusen" 155000 5090 '21423984723847' "LEV")
                ("Ludwigshafen" 154000 6700 '622387399811123125657234' "LU")
                ("Luebeck" 210000 2400 '452387399811123125657234' "HL")
                ("Mainz" 189000 6500 '6132387399811123125657234' "MZ")
                ("Mannheim" 295000 6800 '622387399811123125657234' "MA")
                ("Moenchengladbach" 254000 4050 '2162387399811123125657234' "MG")
                ("Muehlheim(Ruhr)" 172000 4330 '2082934872938472837' "MH")
                ("Muenchen" 1267000 8000 '8298347402394810489134' "M")
                ("Muenster" 270000 4400 '252387399811123125657234' "MS")
                ("Nuernberg" 465000 8500 '912387399811123125657234' "N")
                ("Offenbach(Main)" 107000 6050 '6298347402394810489134' "OF")
                ("Oldenburg" 138000 2900 '442387399811123125657234' "OL")
                ("Osnabrueck" 153000 4500 '542387399811123125657234' "OS")
                ("Paderborn" 110000 4790 '5252387399811123125657234' "PB")
                ("Pforzheim" 104000 7530 '7232387399811123125657234' "PF")
                ("Recklinghausen" 118000 4350 '2362387399811123125657234' "RE")
                ("Regensburg" 124000 8400 '942387399811123125657234' "R")
                ("Remscheid" 121000 5630 '2192387399811123125657234' "RS")
                ("Saarbruecken" 187000 6600 '682387399811123125657234' "SB")
                ("Salzgitter" 106000 3320 '5342387399811123125657234' "SZ")
                ("Siegen" 107000 5900 '272387399811123125657234' "SI")
                ("Solingen" 158000 5650 '2109809328735423498' "SG")
                ("Stuttgart" 562000 7000 '712387399811123125657234' "S")
                ("Wiesbaden" 267000 6200 '6122387399811123125657234' "WI")
                ("Wolfsburg" 122000 3180 '5362387399811123125657234' "WOB")
                ("Wuerzburg" 128000 8700 '932387399811123125657234' "WUE")
                ("Wuppertal" 377000 5600 '2009809328735423498' "W"))));

query setoption("MaxMemPerOperator", 256 * 1024);

#testcase count2
#yields (int 10)
query ten feed count2;


#testcase Filter1
#yields (int 5)
query ten feed filter[.No > 5] consume count;

#testcase Filter2
#yields (int 0)
query ten feed head[0] filter[.No > 5] consume count;

#testcase Filter3
#yields error
query Staedte feed filter[.SName > 5] consume count;

#testcase Average1
#yields (real 325017.2413793103)
query Staedte feed avg[Bev];

#testcase Average2
#yields (real -2.328125)
query real feed avg[No];

#testcase Average3
#yields error
query Staedte feed avg[SName];

#testcase Average4
#yields (real undefined)
query real feed head[0] avg[No];

#testcase Head1
#yields ((rel(tuple((No int))))((1)(2)(3)(4)(5)))
query ten feed head[5] consume;

#testcase Head2
#yields ((rel(tuple((No int))))())
query ten feed head[0] consume;

#testcase Concat1
#yields ((rel(tuple((No int))))((1)(2)(3)(1)(2)(3)))
query ten feed head[3] twenty feed head[3] concat consume;

#testcase Concat2
#yields ((rel(tuple((No int))))((1)(2)(3)))
query ten feed head[0] twenty feed head[3] concat consume;

#testcase Extend1
#yields ((rel(tuple((No int)(Mod2 int))))((1 1)(2 0)(3 1)))
query ten feed extend[Mod2 : .No mod 2] head[3] consume;

#testcase Extend2
#yields ((rel(tuple((No int)(Mod2 int))))())
query ten feed head[0] extend[Mod2 : .No mod 2] head[3] consume;

#testcase Extract1
#yields (int 239000)
query Staedte feed extract[Bev];

#testcase Extract2
#yields (int undefined)
query Staedte feed head[0] extract[Bev];

#testcase Extract3
#yields ((rel(tuple((SName2 string)))) (("Aachen")))
query Staedte feed head[1] groupby[SName; SName2: group feed extract[SName]] project[SName2] consume;


#testcase GroupBy1
#yields ((rel (tuple ((DeptNr int) (Anz int))))((1 2) (2 4) (3 4)))
query Employee feed sortby_old[DeptNr asc] groupby[DeptNr; Anz : group feed count] consume;

#testcase GroupBy2
#yields ((rel (tuple ((DeptNr int) (Anz int))))((1 2) (2 4) (3 4)))
query Employee feed sortby_old[DeptNr asc] groupby[DeptNr; Anz : group count] consume;

#testcase GroupBy3
#yields ((rel (tuple ((DeptNr int) (Anz int))))())
query Employee feed head[0] sortby_old[DeptNr asc] groupby[DeptNr; Anz : group feed count] consume;

#testcase HashJoin1
#yields ((rel(tuple((EName string)(EmpNr int)(DeptNr int)\
    (Leader_A string)(DeptNr_A int))))\
    (("Bush" 11 1 "Bush" 1)("Callahan" 1 2 "Myers" 2)("Jones" 14 2 "Myers" 2)))
query Employee feed Dept feed rename[A] hashjoin[DeptNr, DeptNr_A, 17] sort_old head[3] consume;

#testcase HashJoin2
#yields ((rel(tuple((No int)(No_A int))))((1 1)(6 6)(7 7)(9 9)))
query duplicates feed ten feed rename[A] hashjoin[No, No_A, 23] sort_old rdup consume

#testcase HashJoin3
#yields (int 0)
query Employee feed head[0] Dept feed rename[A] hashjoin[DeptNr, DeptNr_A, 17] count;

#testcase HashJoin4
#yields (int 0)
query Employee feed Dept feed head[0] rename[A] hashjoin[DeptNr, DeptNr_A, 17] count;


#testcase HashJoin5
#yields (int 0)
query Employee feed head[0] Dept feed head[0] rename[A] hashjoin[DeptNr, DeptNr_A, 17] count;

#testcase MergeJoin1
#yields ((rel(tuple((EName string)(EmpNr int)(DeptNr int)\
    (Leader_A string)(DeptNr_A int))))\
    (("Bush" 11 1 "Bush" 1)("Callahan" 1 2 "Myers" 2)("Jones" 14 2 "Myers" 2)))
query Employee feed Dept feed rename[A] sortmergejoin_old[DeptNr, DeptNr_A] sort_old head[3] consume;

#testcase MergeJoin2
#yields ((rel(tuple((No int)(No_A int))))((1 1)(6 6)(7 7)(9 9)))
query duplicates feed ten feed rename[A] mergejoin[No, No_A] sort_old rdup consume

#testcase MergeJoin3
#yields (int 0)
query duplicates feed head[0] ten feed head[0] rename[A] mergejoin[No, No_A] count

#testcase MergeJoin4
#yields (int 0)
query duplicates feed ten feed head[0] rename[A] mergejoin[No, No_A] sort_old rdup count

#testcase MergeJoin5
#yields (int 0)
query duplicates feed head[0] ten feed rename[A] mergejoin[No, No_A] sort_old rdup count

#testcase SortMergeJoin1
#yields (int 0)
query Employee feed head[0] Dept feed rename[A] sortmergejoin_old[DeptNr, DeptNr_A] count;

#testcase SortMergeJoin2
#yields (int 0)
query Employee feed Dept feed head[0] rename[A] sortmergejoin_old[DeptNr, DeptNr_A] count;

#testcase SortMergeJoin3
#yields (int 0)
query Employee feed head[0] Dept feed head[0] rename[A] sortmergejoin_old[DeptNr, DeptNr_A] count;

#testcase SortMergeJoin
#yields (int 10)
query Employee feed Dept feed rename[A] sortmergejoin_old[DeptNr, DeptNr_A] count;


#testcase Max1
#yields (string "Wuppertal")
query Staedte feed max[SName];

#testcase Max2
#yields (string undefined)
query Staedte feed head[0] max[SName];

#testcase Max3
#yields (real 9.0)
query real feed max[No];

#testcase Min1
#yields (string "Aachen")
query Staedte feed min[SName];

#testcase Min2
#yields (real -23.625)
query real feed min[No];

#testcase Sum1
#yields (int 18851000)
query Staedte feed sum[Bev];

#testcase Sum2
#yields (real -18.625)
query real feed sum[No];

#testcase Sum3
#yields (int 0)
query Staedte feed head[0] sum[Bev];

#testcase Product1
#yields error
query ten feed twenty feed product count

#testcase Product2
#yields (int 200)
query ten feed twenty feed rename[A] product count

#testcase Product3
#yields (int 0)
query ten feed twenty feed head[0] rename[A] product count

#testcase Sort1
#yields (int 200)
query ten feed twenty feed rename[A] product sort_old count

#testcase Sort2
#yields (int 0)
query ten feed head[0] twenty feed rename[A] product sort_old count

#testcase Rdup1
#yields (int 20)
query twenty feed ten feed concat sort_old rdup count

#testcase Rdup2
#yields (int 0)
query twenty feed ten feed concat sort_old head[0] rdup count

#testcase Project1
#yields (int 20)
query ten feed twenty feed rename[A] product project[No_A] sort_old rdup count

#testcase Project2
#yields (int 0)
query ten feed head[0] twenty feed rename[A] product project[No_A] sort_old rdup count

#testcase Diff1
#yields (int 10)
query twenty feed odd feed mergediff count

#testcase Diff2
#yields (int 100)
query twenty feed odd feed rename[A] product sort_old ten feed odd feed rename[A] product sort_old mergediff count

#testcase Diff3
#yields (int 20)
query twenty feed odd feed head[0] mergediff count

#testcase Diff4
#yields (int 0)
query twenty feed head[0] odd feed mergediff count

#testcase Sec1
#yields (int 10)
query twenty feed odd feed mergesec count

#testcase Sec2
#yields (int 100)
query twenty feed odd feed rename[A] product sort_old ten feed odd feed rename[A] product sort_old mergesec count

#testcase Sec3
#yields (int 0)
query twenty feed head[0] odd feed mergesec count

#testcase Sec4
#yields (int 2)
query ten feed head[2] rdup ten feed head[2] rdup mergesec count

#testcase Union1
#yields (int 20)
query twenty feed odd feed mergeunion count

#testcase Union2
#yields (int 200)
query twenty feed odd feed rename[A] product sort_old ten feed odd feed rename[A] product sort_old mergeunion count

#testcase Union3
#yields (int 10)
query twenty feed head[0] odd feed mergeunion count

#testcase Sample1
#yields error
query Staedte sample[a, 0.1] count

#testcase Sample2
#yields error
query 1 sample[10, 0.1] count

#testcase Sample3
#yields (int 58)
query Staedte sample[100, 0.01] count

#testcase Sample4
#yields (int 0)
query Staedte feed head[0] consume sample[100, 0.01] count

#testcase Sample5
#yields (int 58)
query Staedte sample[-2345, 200.0] count

#testcase Sample6
#yields (int 10)
query Staedte sample[10, 0.0] count

#testcase Sample7
#yields (int 58)
query Staedte sample[0, 1.0] count


#testcase size1
#yields (bool TRUE)
query Staedte roottuplesize = Staedte feed roottuplesize

#testcase size2
#yields (bool TRUE)
query abs( (Staedte exttuplesize) - (Staedte feed exttuplesize)) < 0.001

#testcase size3
#yields (bool TRUE)
query Staedte tuplesize = Staedte feed tuplesize

#testcase size4
#yields (bool TRUE)
query Staedte rootattrsize[SName] = Staedte feed rootattrsize[SName]

#testcase size5
#yields (bool TRUE)
query Staedte rootattrsize[Kennzeichen] = Staedte feed rootattrsize[Kennzeichen]

#testcase size6
#yields (bool TRUE)
query Staedte rootattrsize[PLZ] = Staedte feed rootattrsize[PLZ]

#testcase size7
#yields (bool TRUE)
query Staedte rootattrsize[Vorwahl] = Staedte feed rootattrsize[Vorwahl]


#testcase size8
#yields (bool TRUE)
query Staedte extattrsize[SName] = Staedte feed extattrsize[SName]

#testcase size9
#yields (bool TRUE)
query Staedte extattrsize[Kennzeichen] = Staedte feed extattrsize[Kennzeichen]

#testcase size10
#yields (bool TRUE)
query Staedte extattrsize[PLZ] = Staedte feed extattrsize[PLZ]

#testcase size11
#yields (bool TRUE)
query Staedte extattrsize[Vorwahl] = Staedte feed extattrsize[Vorwahl]

#testcase size12
#yields (bool TRUE)
query Staedte attrsize[SName] = Staedte feed attrsize[SName]

#testcase size13
#yields (bool TRUE)
query Staedte attrsize[Kennzeichen] = Staedte feed attrsize[Kennzeichen]

#testcase size14
#yields (bool TRUE)
query Staedte attrsize[PLZ] = Staedte feed attrsize[PLZ]

#testcase size15
#yields (bool TRUE)
query Staedte attrsize[Vorwahl] = Staedte feed attrsize[Vorwahl]

#testcase size16
#yields (bool TRUE)
query abs(Staedte roottuplesize - (Staedte rootattrsize[SName] + Staedte rootattrsize[Bev] + Staedte rootattrsize[PLZ] + Staedte rootattrsize[Vorwahl] + Staedte rootattrsize[Kennzeichen])) < 2.e-06

#testcase size17
#yields (bool TRUE)
query abs(Staedte exttuplesize - (Staedte extattrsize[SName] + Staedte extattrsize[Bev] + Staedte extattrsize[PLZ] + Staedte extattrsize[Vorwahl] + Staedte extattrsize[Kennzeichen])) < 2.e-06

#testcase size18
#yields (bool TRUE)
query abs(Staedte tuplesize - (Staedte attrsize[SName] + Staedte attrsize[Bev] + Staedte attrsize[PLZ] + Staedte attrsize[Vorwahl] + Staedte attrsize[Kennzeichen])) < 2.e-06


#testcase intstream1
#yields (bool TRUE)
query intstream(1, 4000000) use[fun(i:int) randint(i)] transformstream sort_old count = 4000000;



##########################################
# Check if the virtual system tables work
##########################################

#testcase SEC2COUNTERS
#yields success
query SEC2COUNTERS feed count;

#testcase SEC2COMMANDS
#yields success
query SEC2COMMANDS feed count;

#testcase SEC2CACHEINFO
#yields success
query SEC2CACHEINFO feed count;

#testcase SEC2FILEINFO
#yields success
query SEC2FILEINFO feed count;

#testcase SEC2TYPEINFO
#yields success
query SEC2TYPEINFO feed count;

#testcase SEC2OPERATORINFO
#yields success
query SEC2OPERATORINFO feed count;

#testcase FLOB1
#yields success
let Staedte_2 = Staedte feed project[Vorwahl] extend[Seq: seqnext()] consume;

#testcase FLOB2
#yields success
query Staedte feed Staedte_2 feed project[Vorwahl] {arg2} product consume count;

#testcase coverage1
#coverage RelationAlgebra

#testcase coverage2
#coverage ExtRelationAlgebra

#teardown
save database to 'relalgtest.db';
close database;
delete database relalgtest;