Changeset: 730c1cd924e6 for MonetDB URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=730c1cd924e6 Modified Files: MonetDB4/tests/BugDay_2005-12-19_4.9.3/Tests/All Branch: default Log Message:
Merge from Jun2010 branch. diffs (truncated from 543 to 300 lines): diff -r 6471ec4d124f -r 730c1cd924e6 MonetDB5/src/mal/Tests/tst450.stable.out.Windows --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/MonetDB5/src/mal/Tests/tst450.stable.out.Windows Wed Jun 23 10:41:58 2010 +0200 @@ -0,0 +1,539 @@ +stdout of test 'tst450` in directory 'src/mal` itself: + + +# 22:19:31 > +# 22:19:31 > Mtimeout -timeout 60 Mserver "--config=/ufs/mk/monet5/src/mal/Tests/All.conf" --debug=10 --set "monet_mod_path=/ufs/mk/monet5/Linux/lib/MonetDB5:/ufs/mk/opensource/MonetDB/Linux/lib/MonetDB" --set "gdk_dbfarm=/ufs/mk/opensource/MonetDB/Linux/var/MonetDB5/dbfarm" --set "sql_logdir=/ufs/mk/opensource/MonetDB/Linux/var/MonetDB5/log" --set mapi_port=30312 --set sql_port=44446 --set xquery_port=54810 --set monet_prompt= --trace "--config=/ufs/mk/monet5/src/mal/Tests/All.conf" --dbname=mTests_src_mal tst450.mal </dev/null +# 22:19:31 > + +# Monet Database Server V4.99.19 +# Copyright (c) 1993-2005, CWI. All rights reserved. +# Compiled for x86_64-redhat-linux-gnu/64bit with 64bit OIDs; dynamically linked. +# config:/ufs/mk/monet5/src/mal/Tests/All.conf +# dbfarm:/ufs/mk/opensource/MonetDB/Linux/var/MonetDB5/dbfarm +# dbname:mTests_src_mal +# Visit http://monetdb.cwi.nl/ for further information. +##testing the inspect module for help information +# +#a:= inspect.getAtomNames(); io.print(a); +#m:= inspect.getModule(); mr:= bat.reverse(m); +#m1:= algebra.kunique(mr); m1r:= bat.reverse(m1); io.print(m1r); +#stmt:= inspect.getDefinition("algebra","select"); +#sig:= inspect.getSignature("algebra","select"); +# +#n:= manual.help("algebra","insert"); io.print(n); +#d:= inspect.getDefinition("inspect","dir"); io.print(d); +# +function user.main():void; +#testing the inspect module for help information + a := inspect.getAtomNames(); + io.print(a); + m := inspect.getModule(); + mr := bat.reverse(m); + m1 := algebra.kunique(mr); + z := algebra.project(m1); + zs := algebra.sortHT(z); + io.print(zs); + stmt := inspect.getDefinition("algebra","select"); + sig := inspect.getSignature("algebra","select"); + n := manual.search("insert"); + io.print(n); +end main; +#-------------------------# +# view atom # name +# int str # type +#-------------------------# +[ 0, "void" ] +[ 1, "bit" ] +[ 2, "chr" ] +[ 3, "bte" ] +[ 4, "sht" ] +[ 5, "BAT" ] +[ 6, "int" ] +[ 7, "oid" ] +[ 8, "wrd" ] +[ 9, "ptr" ] +[ 10, "flt" ] +[ 11, "dbl" ] +[ 12, "lng" ] +[ 13, "str" ] +[ 14, "lock" ] +[ 15, "sema" ] +[ 16, "streams" ] +[ 17, "bstream" ] +[ 18, "blob" ] +[ 19, "sqlblob" ] +[ 20, "color" ] +[ 21, "url" ] +[ 22, "date" ] +[ 23, "daytime" ] +[ 24, "timestamp" ] +[ 25, "timezone" ] +[ 26, "zrule" ] +[ 27, "inet" ] +[ 28, "identifier" ] +[ 29, "pcre" ] +[ 30, "mapentry" ] +#-------------------------# +# t h # name +# oid str # type +#-------------------------# +[ "aggr", nil ] +[ "alarm", nil ] +[ "algebra", nil ] +[ "array", nil ] +[ "bat", nil ] +[ "batcalc", nil ] +[ "batcolor", nil ] +[ "batmmath", nil ] +[ "batmtime", nil ] +[ "batstr", nil ] +[ "bbp", nil ] +[ "blob", nil ] +[ "box", nil ] +[ "bpm", nil ] +[ "bstream", nil ] +[ "calc", nil ] +[ "clients", nil ] +[ "cluster", nil ] +[ "color", nil ] +[ "const", nil ] +[ "constraints", nil ] +[ "crackers", nil ] +[ "date", nil ] +[ "daytime", nil ] +[ "dictionary", nil ] +[ "factories", nil ] +[ "group", nil ] +[ "identifier", nil ] +[ "inet", nil ] +[ "inspect", nil ] +[ "io", nil ] +[ "language", nil ] +[ "lock", nil ] +[ "mal", nil ] +[ "manual", nil ] +[ "mapi", nil ] +[ "master", nil ] +[ "mat", nil ] +[ "mdb", nil ] +[ "mkey", nil ] +[ "mmath", nil ] +[ "mtime", nil ] +[ "octopus", nil ] +[ "optimizer", nil ] +[ "pcre", nil ] +[ "pqueue", nil ] +[ "profiler", nil ] +[ "recycle", nil ] +[ "remote", nil ] +[ "sabaoth", nil ] +[ "scheduler", nil ] +[ "sema", nil ] +[ "slave", nil ] +[ "sql", nil ] +[ "sqlblob", nil ] +[ "statistics", nil ] +[ "status", nil ] +[ "str", nil ] +[ "streams", nil ] +[ "tablet", nil ] +[ "timestamp", nil ] +[ "timezone", nil ] +[ "tokenizer", nil ] +[ "trader", nil ] +[ "transaction", nil ] +[ "txtsim", nil ] +[ "unix", nil ] +[ "url", nil ] +[ "user", nil ] +[ "zrule", nil ] +command bat.insert(b:bat[:any_1,:any_2],h:any_1,t:any_2,force:bit):bat[:any_1,:any_2] address BKCinsert_bun_force; +#Insert one BUN[h,t] in a BAT. + +command bat.insert(b:bat[:any_1,:any_2],h:any_1,t:any_2):bat[:any_1,:any_2] address BKCinsert_bun; +#Insert one BUN[h,t] in a BAT. + +command bat.insert(b:bat[:any_1,:any_2],src:bat[:any_1,:any_2],force:bit):bat[:any_1,:any_2] address BKCinsert_bat_force; +#Insert all BUNs of the second BAT into the first. + +command bat.insert(b:bat[:any_1,:any_2],src:bat[:any_1,:any_2]):bat[:any_1,:any_2] address BKCinsert_bat; +#Insert all BUNs of the second BAT into the first. + +command bat.setSet(b:bat[:any_1,:any_2],mode:bit):bat[:any_1,:any_2] address BKCsetSet; +#Sets the 'set' property on this BAT to 'mode'. In 'set' mode, +#the kernel will silently block insertions that cause a duplicate +#BUN [head,tail] entries in the BAT. KNOWN BUG:when 'set' is set +#to TRUE, this function does not automatically eliminate duplicates. +#Use b := b.sunique; Returns the BAT itself. + +command bat.setKey(b:bat[:any_1,:any_2],mode:bit):bat[:any_1,:any_2] address BKCsetkey; +#Sets the 'key' property of the head column to 'mode'. In 'key' mode, +#the kernel will silently block insertions that cause a duplicate +#entries in the head column. KNOWN BUG:when 'key' is set to TRUE, this +#function does not automatically eliminate duplicates. +#Use b := b.kunique; + +command bpm.insert(pb:bat[:any_1,:any_2],b:bat[:any_1,:any_2]):void address BPMinsert; +#Insert elements into the BAT partitions. + +command cluster.new(b:bat[:oid,:dbl],bits:int,offset:int,order:bit) (psum:bat[:oid,:wrd],map:bat[:oid,:bte]) address CLS_create2_dbl; +#Compute the cluster map for bat b. A cluster map is a list of partition ids. The p(refix) sum is a by product which returns the prefix sum of the per partition frequency. Prefix sum and map can be use to 'cluster' related columns based on b. Incase the offset is non negative it is used to shift the key values. Offset together with the mask bits should make sure that the result of the partitioning can be used in a order by sequence. If this holds and the input is sorted we return a 'compressed' representation of the map, ie [:oid,:bte], the repeated values are not inserted. The order flag indicates that the clustering is used for ordering, ie patition keys aren't fixed so we can internaly optimize partition sizes. + +command cluster.new(b:bat[:oid,:flt],bits:int,offset:int,order:bit) (psum:bat[:oid,:wrd],map:bat[:oid,:bte]) address CLS_create2_flt; +#Compute the cluster map for bat b. A cluster map is a list of partition ids. The p(refix) sum is a by product which returns the prefix sum of the per partition frequency. Prefix sum and map can be use to 'cluster' related columns based on b. Incase the offset is non negative it is used to shift the key values. Offset together with the mask bits should make sure that the result of the partitioning can be used in a order by sequence. If this holds and the input is sorted we return a 'compressed' representation of the map, ie [:oid,:bte], the repeated values are not inserted. The order flag indicates that the clustering is used for ordering, ie patition keys aren't fixed so we can internaly optimize partition sizes. + +command cluster.new(b:bat[:oid,:lng],bits:int,offset:int,order:bit) (psum:bat[:oid,:wrd],map:bat[:oid,:bte]) address CLS_create2_lng; +#Compute the cluster map for bat b. A cluster map is a list of partition ids. The p(refix) sum is a by product which returns the prefix sum of the per partition frequency. Prefix sum and map can be use to 'cluster' related columns based on b. Incase the offset is non negative it is used to shift the key values. Offset together with the mask bits should make sure that the result of the partitioning can be used in a order by sequence. If this holds and the input is sorted we return a 'compressed' representation of the map, ie [:oid,:bte], the repeated values are not inserted. The order flag indicates that the clustering is used for ordering, ie patition keys aren't fixed so we can internaly optimize partition sizes. + +command cluster.new(b:bat[:oid,:wrd],bits:int,offset:int,order:bit) (psum:bat[:oid,:wrd],map:bat[:oid,:bte]) address CLS_create2_wrd; +#Compute the cluster map for bat b. A cluster map is a list of partition ids. The p(refix) sum is a by product which returns the prefix sum of the per partition frequency. Prefix sum and map can be use to 'cluster' related columns based on b. Incase the offset is non negative it is used to shift the key values. Offset together with the mask bits should make sure that the result of the partitioning can be used in a order by sequence. If this holds and the input is sorted we return a 'compressed' representation of the map, ie [:oid,:bte], the repeated values are not inserted. The order flag indicates that the clustering is used for ordering, ie patition keys aren't fixed so we can internaly optimize partition sizes. + +command cluster.new(b:bat[:oid,:int],bits:int,offset:int,order:bit) (psum:bat[:oid,:wrd],map:bat[:oid,:bte]) address CLS_create2_int; +#Compute the cluster map for bat b. A cluster map is a list of partition ids. The p(refix) sum is a by product which returns the prefix sum of the per partition frequency. Prefix sum and map can be use to 'cluster' related columns based on b. Incase the offset is non negative it is used to shift the key values. Offset together with the mask bits should make sure that the result of the partitioning can be used in a order by sequence. If this holds and the input is sorted we return a 'compressed' representation of the map, ie [:oid,:bte], the repeated values are not inserted. The order flag indicates that the clustering is used for ordering, ie patition keys aren't fixed so we can internaly optimize partition sizes. + +command cluster.new(b:bat[:oid,:sht],bits:int,offset:int,order:bit) (psum:bat[:oid,:wrd],map:bat[:oid,:bte]) address CLS_create2_sht; +#Compute the cluster map for bat b. A cluster map is a list of partition ids. The p(refix) sum is a by product which returns the prefix sum of the per partition frequency. Prefix sum and map can be use to 'cluster' related columns based on b. Incase the offset is non negative it is used to shift the key values. Offset together with the mask bits should make sure that the result of the partitioning can be used in a order by sequence. If this holds and the input is sorted we return a 'compressed' representation of the map, ie [:oid,:bte], the repeated values are not inserted. The order flag indicates that the clustering is used for ordering, ie patition keys aren't fixed so we can internaly optimize partition sizes. + +command cluster.new(b:bat[:oid,:chr],bits:int,offset:int,order:bit) (psum:bat[:oid,:wrd],map:bat[:oid,:bte]) address CLS_create2_chr; +#Compute the cluster map for bat b. A cluster map is a list of partition ids. The p(refix) sum is a by product which returns the prefix sum of the per partition frequency. Prefix sum and map can be use to 'cluster' related columns based on b. Incase the offset is non negative it is used to shift the key values. Offset together with the mask bits should make sure that the result of the partitioning can be used in a order by sequence. If this holds and the input is sorted we return a 'compressed' representation of the map, ie [:oid,:bte], the repeated values are not inserted. The order flag indicates that the clustering is used for ordering, ie patition keys aren't fixed so we can internaly optimize partition sizes. + +command cluster.new(b:bat[:oid,:bte],bits:int,offset:int,order:bit) (psum:bat[:oid,:wrd],map:bat[:oid,:bte]) address CLS_create2_bte; +#Compute the cluster map for bat b. A cluster map is a list of partition ids. The p(refix) sum is a by product which returns the prefix sum of the per partition frequency. Prefix sum and map can be use to 'cluster' related columns based on b. Incase the offset is non negative it is used to shift the key values. Offset together with the mask bits should make sure that the result of the partitioning can be used in a order by sequence. If this holds and the input is sorted we return a 'compressed' representation of the map, ie [:oid,:bte], the repeated values are not inserted. The order flag indicates that the clustering is used for ordering, ie patition keys aren't fixed so we can internaly optimize partition sizes. + +command crackers.insert(b:bat[:oid,:dbl],bp:bat[:oid,:dbl],c:bat[:dbl,:dbl]):void address CRKinsert; +#Keep the insertions BAT separatelly and merge in the future on demand with the Ripple + +command crackers.insert(b:bat[:oid,:dbl],bp:bat[:oid,:int],c:bat[:dbl,:int]):void address CRKinsert; +#Keep the insertions BAT separatelly and merge in the future on demand with the Ripple + +command crackers.insert(b:bat[:oid,:dbl],bp:bat[:oid,:str],c:bat[:dbl,:str]):void address CRKinsert; +#Keep the insertions BAT separatelly and merge in the future on demand with the Ripple + +command crackers.insert(b:bat[:oid,:int],bp:bat[:oid,:str],c:bat[:int,:str]):void address CRKinsert; +#Keep the insertions BAT separatelly and merge in the future on demand with the Ripple + +command crackers.insert(b:bat[:oid,:date],bp:bat[:oid,:str],c:bat[:date,:str]):void address CRKinsert; +#Keep the insertions BAT separatelly and merge in the future on demand with the Ripple + +command crackers.insert(b:bat[:oid,:date],bp:bat[:oid,:dbl],c:bat[:date,:dbl]):void address CRKinsert; +#Keep the insertions BAT separatelly and merge in the future on demand with the Ripple + +command crackers.insert(b:bat[:oid,:date],bp:bat[:oid,:lng],c:bat[:date,:lng]):void address CRKinsert; +#Keep the insertions BAT separatelly and merge in the future on demand with the Ripple + +command crackers.insert(b:bat[:oid,:dbl],bp:bat[:oid,:date],c:bat[:dbl,:date]):void address CRKinsert; +#Keep the insertions BAT separatelly and merge in the future on demand with the Ripple + +command crackers.insert(b:bat[:oid,:dbl],bp:bat[:oid,:int],c:bat[:dbl,:int]):void address CRKinsert; +#Keep the insertions BAT separatelly and merge in the future on demand with the Ripple + +command crackers.insert(b:bat[:oid,:date],bp:bat[:oid,:date],c:bat[:date,:date]):void address CRKinsert; +#Keep the insertions BAT separatelly and merge in the future on demand with the Ripple + +command crackers.insert(b:bat[:oid,:date],bp:bat[:oid,:int],c:bat[:date,:int]):void address CRKinsert; +#Keep the insertions BAT separatelly and merge in the future on demand with the Ripple + +command crackers.insert(b:bat[:oid,:int],bp:bat[:oid,:date],c:bat[:int,:date]):void address CRKinsert; +#Keep the insertions BAT separatelly and merge in the future on demand with the Ripple + +command crackers.insert(b:bat[:oid,:int],bp:bat[:oid,:int],c:bat[:int,:int]):void address CRKinsert; +#Keep the insertions BAT separatelly and merge in the future on demand with the Ripple + +command crackers.insertionsBOnNeedGraduallyRipple(b:bat[:any_1,:date],c:bat[:any_1,:date]):void address CRKmergeInsertionsB_OnNeedGraduallyRipple; +#Keep the insertions BAT separatelly and merge only what is needed +#using the ripple strategy if a relevant query arrives in the future + +command crackers.insertionsBOnNeedGradually(b:bat[:any_1,:date],c:bat[:any_1,:date]):void address CRKmergeInsertionsB_OnNeedGradually; +#Keep the insertions BAT separatelly and merge only what is +#needed if a relevant query arrives in the future + +command crackers.insertionsBOnNeed(b:bat[:any_1,:date],c:bat[:any_1,:date]):void address CRKmergeInsertionsB_OnNeed; +#Keep the insertions BAT separatelly and do a complete merge +#only if a relevant query arrives in the future + +command crackers.insertionsForget(b:bat[:any_1,:date],c:bat[:any_1,:date]):void address CRKmergeInsertions_Forget; +#Append c to the cracked BAT of b and completelly forget the cracker index + +command crackers.insertionsBForce(b:bat[:any_1,:date],c:bat[:any_1,:date]):void address CRKmergeInsertionsB_Force_date; +#Merge the insertions BAT with the cracker bat and update the cracker index + +command crackers.insertionsPartiallyForget(b:bat[:any_1,:date],c:bat[:any_1,:date]):void address CRKmergeInsertions_PartiallyForget_date; +#Append c to the cracked BAT of b and partially forget +#the cracker index, i.e., forget only what is affected + +command crackers.insertionsBOnNeedGraduallyRipple(b:bat[:any_1,:dbl],c:bat[:any_1,:dbl]):void address CRKmergeInsertionsB_OnNeedGraduallyRipple; +#Keep the insertions BAT separatelly and merge only what is needed +#using the ripple strategy if a relevant query arrives in the future + +command crackers.insertionsBOnNeedGradually(b:bat[:any_1,:dbl],c:bat[:any_1,:dbl]):void address CRKmergeInsertionsB_OnNeedGradually; +#Keep the insertions BAT separatelly and merge only what is +#needed if a relevant query arrives in the future + +command crackers.insertionsBOnNeed(b:bat[:any_1,:dbl],c:bat[:any_1,:dbl]):void address CRKmergeInsertionsB_OnNeed; +#Keep the insertions BAT separatelly and do a complete merge +#only if a relevant query arrives in the future + +command crackers.insertionsForget(b:bat[:any_1,:dbl],c:bat[:any_1,:dbl]):void address CRKmergeInsertions_Forget; +#Append c to the cracked BAT of b and completelly forget the cracker index + +command crackers.insertionsBForce(b:bat[:any_1,:dbl],c:bat[:any_1,:dbl]):void address CRKmergeInsertionsB_Force_dbl; +#Merge the insertions BAT with the cracker bat and update the cracker index + +command crackers.insertionsPartiallyForget(b:bat[:any_1,:dbl],c:bat[:any_1,:dbl]):void address CRKmergeInsertions_PartiallyForget_dbl; +#Append c to the cracked BAT of b and partially forget +#the cracker index, i.e., forget only what is affected + +command crackers.insertionsBOnNeedGraduallyRipple(b:bat[:any_1,:flt],c:bat[:any_1,:flt]):void address CRKmergeInsertionsB_OnNeedGraduallyRipple; +#Keep the insertions BAT separatelly and merge only what is needed +#using the ripple strategy if a relevant query arrives in the future + +command crackers.insertionsBOnNeedGradually(b:bat[:any_1,:flt],c:bat[:any_1,:flt]):void address CRKmergeInsertionsB_OnNeedGradually; +#Keep the insertions BAT separatelly and merge only what is +#needed if a relevant query arrives in the future + +command crackers.insertionsBOnNeed(b:bat[:any_1,:flt],c:bat[:any_1,:flt]):void address CRKmergeInsertionsB_OnNeed; +#Keep the insertions BAT separatelly and do a complete merge +#only if a relevant query arrives in the future _______________________________________________ Checkin-list mailing list Checkin-list@monetdb.org http://mail.monetdb.org/mailman/listinfo/checkin-list
