Update of /cvsroot/monetdb/MonetDB5/src/mal/Tests
In directory sc8-pr-cvs16.sourceforge.net:/tmp/cvs-serv17771/src/mal/Tests
Modified Files:
tst450.stable.out
Log Message:
comit partial sideways cracking
incrementaly build and maintain cracker maps to provide a self-organizing
behavior depending on available storage
each map is now a collection of separate pieces that can be cracked, updated,
removed, recreated etc independently
this comit also ports the whole cracking code base to GDK2
all two-column table cracking structures e.g., cracker maps etc become two
single columns
the first experiments show "identical" performance for the latest partial
sideways cracking exps
finally commit the ongoing cracking joins code
Index: tst450.stable.out
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/mal/Tests/tst450.stable.out,v
retrieving revision 1.193
retrieving revision 1.194
diff -u -d -r1.193 -r1.194
--- tst450.stable.out 21 Dec 2007 15:29:34 -0000 1.193
+++ tst450.stable.out 14 Jan 2008 22:24:21 -0000 1.194
@@ -97,6 +97,7 @@
[ "color", nil ]
[ "const", nil ]
[ "constraints", nil ]
+[ "crackers", nil ]
[ "date", nil ]
[ "daytime", nil ]
[ "factory", nil ]
@@ -164,6 +165,247 @@
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
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,: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
+
+command crackers.insertionsForget(b:bat[:any_1,:flt],c:bat[:any_1,:flt]):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,:flt],c:bat[:any_1,:flt]):void
address CRKmergeInsertionsB_Force_flt;
+#Merge the insertions BAT with the cracker bat and update the cracker index
+
+command
crackers.insertionsPartiallyForget(b:bat[:any_1,:flt],c:bat[:any_1,:flt]):void
address CRKmergeInsertions_PartiallyForget_flt;
+#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,:lng],c:bat[:any_1,:lng]):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,:lng],c:bat[:any_1,:lng]):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,:lng],c:bat[:any_1,:lng]):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,:lng],c:bat[:any_1,:lng]):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,:lng],c:bat[:any_1,:lng]):void
address CRKmergeInsertionsB_Force_lng;
+#Merge the insertions BAT with the cracker bat and update the cracker index
+
+command
crackers.insertionsPartiallyForget(b:bat[:any_1,:lng],c:bat[:any_1,:lng]):void
address CRKmergeInsertions_PartiallyForget_lng;
+#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,:int],c:bat[:any_1,:int]):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,:int],c:bat[:any_1,:int]):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,:int],c:bat[:any_1,:int]):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,:int],c:bat[:any_1,:int]):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,:int],c:bat[:any_1,:int]):void
address CRKmergeInsertionsB_Force_int;
+#Merge the insertions BAT with the cracker bat and update the cracker index
+
+command
crackers.insertionsPartiallyForget(b:bat[:any_1,:int],c:bat[:any_1,:int]):void
address CRKmergeInsertions_PartiallyForget_int;
+#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,:sht],c:bat[:any_1,:sht]):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,:sht],c:bat[:any_1,:sht]):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,:sht],c:bat[:any_1,:sht]):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,:sht],c:bat[:any_1,:sht]):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,:sht],c:bat[:any_1,:sht]):void
address CRKmergeInsertionsB_Force_sht;
+#Merge the insertions BAT with the cracker bat and update the cracker index
+
+command
crackers.insertionsPartiallyForget(b:bat[:any_1,:sht],c:bat[:any_1,:sht]):void
address CRKmergeInsertions_PartiallyForget_sht;
+#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,:chr],c:bat[:any_1,:chr]):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,:chr],c:bat[:any_1,:chr]):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,:chr],c:bat[:any_1,:chr]):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,:chr],c:bat[:any_1,:chr]):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,:chr],c:bat[:any_1,:chr]):void
address CRKmergeInsertionsB_Force_chr;
+#Merge the insertions BAT with the cracker bat and update the cracker index
+
+command
crackers.insertionsPartiallyForget(b:bat[:any_1,:chr],c:bat[:any_1,:chr]):void
address CRKmergeInsertions_PartiallyForget_chr;
+#Append c to the cracked BAT of b and partially forget
+#the cracker index, i.e., forget only what is affected
+
+command
crackers.printPendingInsertions(b:bat[:oid,:date],bp:bat[:oid,:lng]):void
address CRKprintPendingInsertions;
+#Print the pending insertions
+
+command
crackers.printPendingInsertions(b:bat[:oid,:date],bp:bat[:oid,:date]):void
address CRKprintPendingInsertions;
+#Print the pending insertions
+
+command
crackers.printPendingInsertions(b:bat[:oid,:date],bp:bat[:oid,:int]):void
address CRKprintPendingInsertions;
+#Print the pending insertions
+
+command
crackers.printPendingInsertions(b:bat[:oid,:int],bp:bat[:oid,:date]):void
address CRKprintPendingInsertions;
+#Print the pending insertions
+
+command
crackers.printPendingInsertions(b:bat[:oid,:int],bp:bat[:oid,:int]):void
address CRKprintPendingInsertions;
+#Print the pending insertions
+
+command crackers.printCrackerInsertions(b:bat[:any_1,:date]):void address
CRKprintCrackerInsertions;
+#Print the pending insertions of the cracker BAT of b
+
+command crackers.printCrackerInsertions(b:bat[:any_1,:dbl]):void address
CRKprintCrackerInsertions;
+#Print the pending insertions of the cracker BAT of b
+
+command crackers.printCrackerInsertions(b:bat[:any_1,:flt]):void address
CRKprintCrackerInsertions;
+#Print the pending insertions of the cracker BAT of b
+
+command crackers.printCrackerInsertions(b:bat[:any_1,:lng]):void address
CRKprintCrackerInsertions;
+#Print the pending insertions of the cracker BAT of b
+
+command crackers.printCrackerInsertions(b:bat[:any_1,:int]):void address
CRKprintCrackerInsertions;
+#Print the pending insertions of the cracker BAT of b
+
+command crackers.printCrackerInsertions(b:bat[:any_1,:sht]):void address
CRKprintCrackerInsertions;
+#Print the pending insertions of the cracker BAT of b
+
+command crackers.printCrackerInsertions(b:bat[:any_1,:chr]):void address
CRKprintCrackerInsertions;
+#Print the pending insertions of the cracker BAT of b
+
+command
crackers.sizePendingInsertions(b:bat[:oid,:date],bp:bat[:oid,:lng]):void
address CRKsizePendingInsertions;
+#Get the size of the pending insertions for this map
+
+command
crackers.sizePendingInsertions(b:bat[:oid,:date],bp:bat[:oid,:date]):void
address CRKsizePendingInsertions;
+#Get the size of the pending insertions for this map
+
+command
crackers.sizePendingInsertions(b:bat[:oid,:date],bp:bat[:oid,:int]):void
address CRKsizePendingInsertions;
+#Get the size of the pending insertions for this map
+
+command
crackers.sizePendingInsertions(b:bat[:oid,:int],bp:bat[:oid,:date]):void
address CRKsizePendingInsertions;
+#Get the size of the pending insertions for this map
+
+command
crackers.sizePendingInsertions(b:bat[:oid,:int],bp:bat[:oid,:int]):void address
CRKsizePendingInsertions;
+#Get the size of the pending insertions for this map
+
+command crackers.sizeCrackerInsertions(b:bat[:any_1,:date]):void address
CRKsizeCrackerInsertions;
+#Get the size of the pending insertions of the cracker BAT of b
+
+command crackers.sizeCrackerInsertions(b:bat[:any_1,:dbl]):void address
CRKsizeCrackerInsertions;
+#Get the size of the pending insertions of the cracker BAT of b
+
+command crackers.sizeCrackerInsertions(b:bat[:any_1,:flt]):void address
CRKsizeCrackerInsertions;
+#Get the size of the pending insertions of the cracker BAT of b
+
+command crackers.sizeCrackerInsertions(b:bat[:any_1,:lng]):void address
CRKsizeCrackerInsertions;
+#Get the size of the pending insertions of the cracker BAT of b
+
+command crackers.sizeCrackerInsertions(b:bat[:any_1,:int]):void address
CRKsizeCrackerInsertions;
+#Get the size of the pending insertions of the cracker BAT of b
+
+command crackers.sizeCrackerInsertions(b:bat[:any_1,:sht]):void address
CRKsizeCrackerInsertions;
+#Get the size of the pending insertions of the cracker BAT of b
+
+command crackers.sizeCrackerInsertions(b:bat[:any_1,:chr]):void address
CRKsizeCrackerInsertions;
+#Get the size of the pending insertions of the cracker BAT of b
+
command io.import(b:bat[:any_1,:any_2],filepath:str):bat[:any_1,:any_2]
address IOimport;
#Import a BAT from an ASCII dump. The new tuples are *inserted* into the
#parameter BAT. You have to create it! Its signature must match the dump,
-------------------------------------------------------------------------
Check out the new SourceForge.net Marketplace.
It's the best place to buy or sell services for
just about anything Open Source.
http://ad.doubleclick.net/clk;164216239;13503038;w?http://sf.net/marketplace
_______________________________________________
Monetdb-checkins mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/monetdb-checkins
