tst450.stable.out

一个内存数据库的源代码这是服务器端还有客户端

#Append c to the cracked bat of b and partially forget the cracker index, i.e., forget only what is affected

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.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.insertionsOnNeedGraduallyRipple(b:bat[:any_1,:flt],c:bat[:any_1,:flt],deleteNodes:bit):void address CRKmergeInsertions_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.insertionsOnNeedGradually(b:bat[:any_1,:flt],c:bat[:any_1,:flt],deleteNodes:bit):void address CRKmergeInsertions_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.insertionsOnNeed(b:bat[:any_1,:flt],c:bat[:any_1,:flt],deleteNodes:bit):void address CRKmergeInsertions_OnNeed;
#Keep the insertions bat separatelly and do a complete merge only if a relevant query arrives in the future

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.insertionsForce(b:bat[:any_1,:flt],c:bat[:any_1,:flt],deleteNodes:bit):void address CRKmergeInsertions_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.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.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.insertionsOnNeedGraduallyRipple(b:bat[:any_1,:lng],c:bat[:any_1,:lng],deleteNodes:bit):void address CRKmergeInsertions_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.insertionsOnNeedGradually(b:bat[:any_1,:lng],c:bat[:any_1,:lng],deleteNodes:bit):void address CRKmergeInsertions_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.insertionsOnNeed(b:bat[:any_1,:lng],c:bat[:any_1,:lng],deleteNodes:bit):void address CRKmergeInsertions_OnNeed;
#Keep the insertions bat separatelly and do a complete merge only if a relevant query arrives in the future

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.insertionsForce(b:bat[:any_1,:lng],c:bat[:any_1,:lng],deleteNodes:bit):void address CRKmergeInsertions_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.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.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.insertionsOnNeedGraduallyRipple(b:bat[:any_1,:int],c:bat[:any_1,:int],deleteNodes:bit):void address CRKmergeInsertions_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.insertionsOnNeedGradually(b:bat[:any_1,:int],c:bat[:any_1,:int],deleteNodes:bit):void address CRKmergeInsertions_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.insertionsOnNeed(b:bat[:any_1,:int],c:bat[:any_1,:int],deleteNodes:bit):void address CRKmergeInsertions_OnNeed;
#Keep the insertions bat separatelly and do a complete merge only if a relevant query arrives in the future

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.insertionsForce(b:bat[:any_1,:int],c:bat[:any_1,:int],deleteNodes:bit):void address CRKmergeInsertions_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.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.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.insertionsOnNeedGraduallyRipple(b:bat[:any_1,:sht],c:bat[:any_1,:sht],deleteNodes:bit):void address CRKmergeInsertions_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.insertionsOnNeedGradually(b:bat[:any_1,:sht],c:bat[:any_1,:sht],deleteNodes:bit):void address CRKmergeInsertions_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.insertionsOnNeed(b:bat[:any_1,:sht],c:bat[:any_1,:sht],deleteNodes:bit):void address CRKmergeInsertions_OnNeed;
#Keep the insertions bat separatelly and do a complete merge only if a relevant query arrives in the future

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.insertionsForce(b:bat[:any_1,:sht],c:bat[:any_1,:sht],deleteNodes:bit):void address CRKmergeInsertions_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.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.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.insertionsOnNeedGraduallyRipple(b:bat[:any_1,:chr],c:bat[:any_1,:chr],deleteNodes:bit):void address CRKmergeInsertions_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.insertionsOnNeedGradually(b:bat[:any_1,:chr],c:bat[:any_1,:chr],deleteNodes:bit):void address CRKmergeInsertions_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.insertionsOnNeed(b:bat[:any_1,:chr],c:bat[:any_1,:chr],deleteNodes:bit):void address CRKmergeInsertions_OnNeed;
#Keep the insertions bat separatelly and do a complete merge only if a relevant query arrives in the future

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.insertionsForce(b:bat[:any_1,:chr],c:bat[:any_1,:chr],deleteNodes:bit):void address CRKmergeInsertions_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.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.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.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,
#else parsing errors will occur and FALSE is returned.

command str.insert(s:str,start:int,l:int,s2:str):str address STRinsert;
#Insert a string into another

command transaction.alpha(b:bat[:any_1,:any_2]):bat[:any_1,:any_2] address TRNtrans_alpha;
#List insertions since last commit.

[ nil ]
#-----------------#
# view	fcn	  # name
# int	str	  # type
#-----------------#

# 22:19:31 >  
# 22:19:31 >  Done.
# 22:19:31 >