Update of /cvsroot/monetdb/MonetDB5/src/modules/mal
In directory sc8-pr-cvs16.sourceforge.net:/tmp/cvs-serv11183/src/modules/mal
Modified Files:
algebraExtensions.mx batExtensions.mx batxml.mx bbp.mx box.mx
bpm.mx const.mx constraints.mx factory.mx fleet.mx language.mx
mal_mapi.mx
Log Message:
propagated changes of Friday Feb 08 2008 - Sunday Feb 10 2008
from the MonetDB_5-4 branch to the development trunk
Index: factory.mx
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/modules/mal/factory.mx,v
retrieving revision 1.25
retrieving revision 1.26
diff -u -d -r1.25 -r1.26
--- factory.mx 11 Jan 2008 10:41:37 -0000 1.25
+++ factory.mx 10 Feb 2008 23:48:50 -0000 1.26
@@ -25,27 +25,27 @@
command getPlants()(mod:bat[:oid,:str], fcn:bat[:oid,:str])
address FCTgetPlants
-comment "Retrieve the names for all active factories";
+comment "Retrieve the names for all active factories.";
command getCaller():int
address FCTgetCaller
-comment "Retrieve the unique identity of the factory caller";
+comment "Retrieve the unique identity of the factory caller.";
command getOwners():bat[:oid,:str]
address FCTgetOwners
-comment "Retrieve the factory owners table";
+comment "Retrieve the factory owners table.";
command getArrival():bat[:oid,:timestamp]
address FCTgetArrival
-comment "Retrieve the time stamp the last call was made";
+comment "Retrieve the time stamp the last call was made.";
command getDeparture():bat[:oid,:timestamp]
address FCTgetDeparture
-comment "Retrieve the time stamp the last answer was returned";
+comment "Retrieve the time stamp the last answer was returned.";
command shutdown(m:str, f:str):void
address FCTshutdown
-comment "Close a factory";
+comment "Close a factory.";
@-
@{
@include prelude.mx
Index: constraints.mx
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/modules/mal/constraints.mx,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -d -r1.10 -r1.11
--- constraints.mx 11 Jan 2008 10:41:37 -0000 1.10
+++ constraints.mx 10 Feb 2008 23:48:48 -0000 1.11
@@ -23,7 +23,7 @@
command emptySet(b:bat[:oid,:any_2]):void
address CemptySet
-comment "Check if the bat is empty";
+comment "Check if the BAT is empty.";
@h
#ifndef _CONSTRAINTS_H
Index: batxml.mx
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/modules/mal/batxml.mx,v
retrieving revision 1.24
retrieving revision 1.25
diff -u -d -r1.24 -r1.25
--- batxml.mx 8 Feb 2008 22:36:34 -0000 1.24
+++ batxml.mx 10 Feb 2008 23:48:46 -0000 1.25
@@ -33,43 +33,43 @@
command xml.xml(src:bat[:oid,:str]):bat[:oid,:xml]
address BATXMLstr2xml
-comment "Cast the string to an xml compliant string";
+comment "Cast the string to an xml compliant string.";
command xml.str(src:bat[:oid,:xml]):bat[:oid,:str]
address BATXMLxml2str
-comment "Cast the string to an xml compliant string";
+comment "Cast the string to an xml compliant string.";
command xml.document(src:bat[:oid,:str]):bat[:oid,:xml]
address BATXMLdocument
-comment "Parse the string as a document";
+comment "Parse the string as an XML document.";
command xml.content(src:bat[:oid,:str]):bat[:oid,:xml]
address BATXMLcontent
-comment "Parse the string as a document";
+comment "Parse the string as an XML document.";
command xml.tag(nme:str,val:bat[:oid,:xml]):bat[:oid,:xml]
address BATXMLtag
-comment "Routine to put element brackets around an XML value";
+comment "Put element brackets around an XML value.";
command xml.comment(val:bat[:oid,:str]):bat[:oid,:xml]
address BATXMLcomment
-comment "Construct an comment struction ";
+comment "Create an XML comment element.";
command xml.parse(val:bat[:oid,:str]):bat[:oid,:xml]
address BATXMLparse
-comment "Parse the XML document or element string values ";
+comment "Parse the XML document or element string values. ";
command xml.serialize(val:bat[:oid,:str]):bat[:oid,:xml]
address BATXMLxml2str
-comment "Serialize the XML object to a string";
+comment "Serialize the XML object to a string.";
command xml.text(val:bat[:oid,:str]):bat[:oid,:xml]
address BATXMLxml2str
-comment "Serialize the XQuery object to a string";
+comment "Serialize the XML object to a string.";
command xml.xquery(val:bat[:oid,:str],expr:str):bat[:oid,:xml]
address BATXMLxquery
-comment "Execute the XQuery against the elements";
+comment "Execute the XQuery against the elements.";
#todo
#command xml.table(val:bat[:oid,:str],expr:str):bat[:oid,:xml]
@@ -78,51 +78,51 @@
command xml.pi(operator:str, ret:bat[:oid,:xml]):bat[:oid,:xml]
address XMLpi
-comment "Call the processing instruction";
+comment "Call the XML processing instruction.";
command xml.attribute(name:str, val:bat[:oid,:str]):bat[:oid,:xml]
address BATXMLattribute
-comment "Construct an attribute value pair";
+comment "Construct an attribute value pair.";
command xml.element(name:str, s:bat[:oid,:xml]) :bat[:oid,:xml]
address BATXMLtag
-comment "The basic building block for XML elements are namespaces, attributes
and a sequence of xml elements. The name space and the attributes may be left
unspecified.";
+comment "The basic building block for XML elements are namespaces, attributes
and a sequence of XML elements. The name space and the attributes may be left
unspecified.";
command xml.options(tag:str, option:str,left:bat[:oid,:xml]):bat[:oid,:xml]
address BATXMLoptions
-comment "Create the components including NULL conversions";
+comment "Create the components including NULL conversions.";
command xml.element(name:str, ns:xml, attr:xml,
s:bat[:oid,:xml]):bat[:oid,:xml]
address BATXMLelement
-comment "The basic building block for XML elements are namespaces, attributes
and a sequence of xml elements. The name space and the attributes may be left
unspecified(=nilt).";
+comment "The basic building block for XML elements are namespaces, attributes
and a sequence of XML elements. The name space and the attributes may be left
unspecified(=nil).";
command xml.concat(left:bat[:oid,:xml],right:bat[:oid,:xml] ):bat[:oid,:xml]
address BATXMLconcat
-comment "Concatenate the xml values";
+comment "Concatenate the XML values.";
pattern xml.forest(val:bat[:oid,:xml]...):bat[:oid,:xml]
address BATXMLforest
-comment "Construct an element list";
+comment "Construct an element list.";
command
xml.agg(val:bat[:oid,:xml],grp:bat[:oid,:oid],e:bat[:oid,:any_1]):bat[:oid,:xml]
address BATXMLagg3
-comment "Aggregate the XML values over grouping specified";
+comment "Aggregate the XML values over groups specified.";
command xml.agg(val:bat[:oid,:xml],grp:bat[:oid,:oid]):bat[:oid,:xml]
address BATXMLagg
-comment "Aggregate the XML values over grouping specified";
+comment "Aggregate the XML values over groups specified.";
command xml.agg(val:bat[:oid,:xml]):bat[:oid,:xml]
address BATXMLgroup
-comment "Aggregate the XML values over grouping specified";
+comment "Aggregate the XML values over groups specified.";
command xml.root(val:bat[:oid,:xml], version:str,
standalone:str):bat[:oid,:xml]
address BATXMLroot
-comment "Contruct the root nodes";
+comment "Contruct the root nodes.";
command xml.isdocument(val:bat[:oid,:str]):bat[:oid,:bit]
address BATXMLisdocument
-comment "Validate the string as a document";
+comment "Validate the string as a XML document.";
module batcalc;
command xml(src:bat[:oid,:str]):bat[:oid,:xml] address BATXMLstr2xml;
Index: const.mx
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/modules/mal/const.mx,v
retrieving revision 1.49
retrieving revision 1.50
diff -u -d -r1.49 -r1.50
--- const.mx 11 Jan 2008 10:41:37 -0000 1.49
+++ const.mx 10 Feb 2008 23:48:47 -0000 1.50
@@ -39,41 +39,41 @@
pattern open():void
address CSTopen
-comment "Locate and open the constant box";
+comment "Locate and open the constant box.";
pattern close():void
address CSTclose
-comment "Close the constant box ";
+comment "Close the constant box.";
pattern destroy():void
address CSTdestroy
-comment "Destroy the box";
+comment "Destroy the box.";
pattern take(name:str):any_1
address CSTtake
-comment "Take a variable out of the box";
+comment "Take a variable out of the box.";
pattern deposit(name:str,val:any_1) :void
address CSTdeposit
-comment "Enter a new variable into the box";
+comment "Add a variable to the box.";
pattern releaseAll():void
address CSTreleaseAll
-comment "Release all variables in the box";
+comment "Release all variables in the box.";
pattern release(name:str) :void
address CSTrelease
-comment "Release a new constant value";
+comment "Release a constant value.";
pattern release(name:any_1):void
address CSTrelease
-comment "Release a new constant value";
+comment "Release a constant value.";
pattern toString(name:any_1):str
address CSTtoString
-comment "Get the string representation of an element in the box";
+comment "Get the string representation of an element in the box.";
pattern discard(name:any_1) :void
address CSTdiscard
-comment "Release the const from the box";
+comment "Release the const from the box.";
pattern newIterator()(:lng,:str)
address CSTnewIterator
-comment "Locate next element in the box";
+comment "Locate next element in the box.";
pattern hasMoreElements()(:lng,:str)
address CSThasMoreElements
-comment "Locate next element in the box";
+comment "Locate next element in the box.";
@{
pattern prelude():void
Index: language.mx
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/modules/mal/language.mx,v
retrieving revision 1.64
retrieving revision 1.65
diff -u -d -r1.64 -r1.65
--- language.mx 11 Jan 2008 10:41:37 -0000 1.64
+++ language.mx 10 Feb 2008 23:48:50 -0000 1.65
@@ -82,32 +82,32 @@
address MALassertOid;
pattern assert(v:any_1,pname:str,oper:str,val:any_2):void
address MALassertTriple
-comment "Assertion test";
+comment "Assertion test.";
pattern assertSpace(depth:int)
address MALsafeguardStack
comment "Ensures that the current call does not consume
-more then depth*vtop elements on the stack";
+more then depth*vtop elements on the stack.";
pattern dataflow():int
address MALstartDataflow
comment "The current guarded block is executed using
-dataflow control ";
+dataflow control.";
command register(m:str,f:str,code:str,help:str):void
address CMDregisterFunction
-comment"Compile the code string and register it as a MAL function";
+comment"Compile the code string and register it as a MAL function.";
pattern call(s:str):void
address CMDcallString
-comment "Evaluate a MAL string program";
+comment "Evaluate a MAL string program.";
pattern call(s:bat[:oid,:str]):void
address CMDcallBAT
-comment "Evaluate a program stored in a BAT";
+comment "Evaluate a program stored in a BAT.";
command source(f:str):void
address CMDevalFile
comment "Merge the instructions stored in the
- file with the current program";
+ file with the current program.";
@{
@+ Dummy code
Index: bpm.mx
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/modules/mal/bpm.mx,v
retrieving revision 1.124
retrieving revision 1.125
diff -u -d -r1.124 -r1.125
--- bpm.mx 7 Feb 2008 08:18:12 -0000 1.124
+++ bpm.mx 10 Feb 2008 23:48:47 -0000 1.125
@@ -29,11 +29,11 @@
based on splitting by tail value.
The following MAL program illustrates the snippet of actions needed:
@example
- bpm.open();
- Ralias:= bpm.deposit("myversion",R:bat[:oid,:int]);
- bpm.rangePartition(Ralias,nil:int,100);
- bpm.rangePartition(Ralias,101,200);
- bpm.close();
+bpm.open();
+Ralias:= bpm.deposit("myversion",R:bat[:oid,:int]);
+bpm.rangePartition(Ralias,nil:int,100);
+bpm.rangePartition(Ralias,101,200);
+bpm.close();
@end example
The command @sc{bpm.deposit} registers a BAT as one
for which a partitioned copy is required.
@@ -48,11 +48,11 @@
The partition manager also supports hash-based partitioning.
Its argument is the number of hash bucket bits.
@example
- bpm.open();
- Rev:= bat.reverse(R:bat[:oid,:int]);
- Ralias:= bpm.deposit("myHashVersion",Rev); # creates side effects
- bpm.hashPartition(Ralias,2);
- bpm.close();
+bpm.open();
+Rev:= bat.reverse(R:bat[:oid,:int]);
+Ralias:= bpm.deposit("myHashVersion",Rev); # creates side effects
+bpm.hashPartition(Ralias,2);
+bpm.close();
@end example
This example creates a hash-partition based on the head.
@@ -67,7 +67,7 @@
Assume a relation R(A,B) which is already partitioned on A
the derived fragmentation on the head is enforced with
@example
- bpm.derivePartition(B,A);
+bpm.derivePartition(B,A);
@end example
@- Using partitions
The partitioned BAT can be used in two ways. A query plan can be
@@ -79,17 +79,17 @@
a partitioned BAT. In this example we collect the partial
results in the accumulator BAT U.
@example
- bpm.open();
- Ralias:bat[:oid,:int]:= bpm.take("myversion");
- U:= bat.new(:oid,:int);
+ bpm.open();
+ Ralias:bat[:oid,:int]:= bpm.take("myversion");
+ U:= bat.new(:oid,:int);
barrier Rp:= bpm.newIterator(Ralias);
- ...
- t:= algebra.select(Rp,0,100);
- U:= algebra.union(tu,t);
- ...
- redo Rp:= bpm.hasMoreElements(Ralias);
+ ...
+ t:= algebra.select(Rp,0,100);
+ U:= algebra.union(tu,t);
+ ...
+ redo Rp:= bpm.hasMoreElements(Ralias);
exit Rp;
- bpm.close();
+ bpm.close();
@end example
The properties of the partitioned BATs are particularly useful during query
@@ -100,21 +100,21 @@
To illustrate, the same problem handled by an optimizer that produces the plan
based on a known number of partitions:
@example
- bpm.open();
- R:bat[:oid,:int]:= bpm.take("myversion"); # get the partition alias
- optimizer.mergetable();
- T:= algebra.select(R,0,100);
+ bpm.open();
+ R:bat[:oid,:int]:= bpm.take("myversion"); # get the partition alias
+ optimizer.mergetable();
+ T:= algebra.select(R,0,100);
@end example
is translated to the plan:
@example
- bpm.open();
- R:bat[:oid,:int]:= bpm.take("myversion"); # get the partition alias
- R0:bat[:oid,:int]:= bpm.take(R,0, nil:oid,nil:oid, 0,100);
- R1:bat[:oid,:int]:= bpm.take(R,1, nil:oid,nil:oid, 101,200);
- R2:bat[:oid,:int]:= bpm.take(R,2, nil:oid,nil:oid, 201,nil:int);
- R:= mat.new(R0,R1,R2);
- T:= algebra.select(R,0,100);
- optimizer.multitable();
+ bpm.open();
+ R:bat[:oid,:int]:= bpm.take("myversion"); # get the partition alias
+ R0:bat[:oid,:int]:= bpm.take(R,0, nil:oid,nil:oid, 0,100);
+ R1:bat[:oid,:int]:= bpm.take(R,1, nil:oid,nil:oid, 101,200);
+ R2:bat[:oid,:int]:= bpm.take(R,2, nil:oid,nil:oid, 201,nil:int);
+ R:= mat.new(R0,R1,R2);
+ T:= algebra.select(R,0,100);
+ optimizer.multitable();
@end example
In this translation Ri also gets the properties of the BATs.
It is now up to the @sc{mat} optimizer to decide about
@@ -127,12 +127,12 @@
Once the transaction is commited, the updates are propagated
(in parallel) to all partitions.
@example
- bpm.open();
- Ralias:bat[:oid,:int] := bpm.take("myversion");
- bpm.insert(Ralias, Rinsert); # handle pending inserts
- bpm.delete(Ralias, Rdelete); # handle pending deletes
- bpm.replace(Ralias, Rold, Rnew); # handle pending updates
- bpm.close();
+ bpm.open();
+ Ralias:bat[:oid,:int] := bpm.take("myversion");
+ bpm.insert(Ralias, Rinsert);# handle pending inserts
+ bpm.delete(Ralias, Rdelete);# handle pending deletes
+ bpm.replace(Ralias, Rold, Rnew);# handle pending updates
+ bpm.close();
@end example
The @sc{replace} operator works on the assumption that
the head of @sc{Rold} and @sc{Rnew} is unique.
@@ -152,23 +152,23 @@
In the previous plan for this becomes
@example
- bpm.open();
- Tmp := bpm.deposit("tmp",:bat[:oid,:int]);
- bpm.rangePartition(tmp,nil:int,100);
- bpm.rangePartition(tmp,101,nil:int);
+ bpm.open();
+ Tmp := bpm.deposit("tmp",:bat[:oid,:int]);
+ bpm.rangePartition(tmp,nil:int,100);
+ bpm.rangePartition(tmp,101,nil:int);
- Ralias:bat[:oid,:int]:= bpm.take("myversion"); # get the partition alias
- R0:bat[:oid,:int]:= bpm.take("myversion", nil:oid,nil:oid, 0,100);
- T0:= algebra.select(R0,0,100);
- bpm.insert(Tmp,T0);
+ Ralias:bat[:oid,:int]:= bpm.take("myversion"); # get the partition alias
+ R0:bat[:oid,:int]:= bpm.take("myversion", nil:oid,nil:oid, 0,100);
+ T0:= algebra.select(R0,0,100);
+ bpm.insert(Tmp,T0);
- R1:bat[:oid,:int]:= bpm.take("myversion", nil:oid,nil:oid, 101,200);
- T1:= algebra.select(R1,0,100);
- bpm.insert(Tmp,T1);
+ R1:bat[:oid,:int]:= bpm.take("myversion", nil:oid,nil:oid, 101,200);
+ T1:= algebra.select(R1,0,100);
+ bpm.insert(Tmp,T1);
- R2:bat[:oid,:int]:= bpm.take("myversion", nil:oid,nil:oid, 201,nil:int);
- T2:= algebra.select(R2,0,100);
- bpm.insert(Tmp,T2);
+ R2:bat[:oid,:int]:= bpm.take("myversion", nil:oid,nil:oid, 201,nil:int);
+ T2:= algebra.select(R2,0,100);
+ bpm.insert(Tmp,T2);
@end example
Note that a symbolic optimizer can reduce this plan to a small snippet.
@@ -181,28 +181,28 @@
stored in the BPM catalog. Instead, the mat approach could
be used to reduce the plan size.
@example
- bpm.open();
- Ralias:= bpm.take("myversion",:bat[:oid,:int]); # get the partition
alias
- [EMAIL PROTECTED]:oid,hhigh=nil:oid,tlow=nil:int,[EMAIL PROTECTED]:=
bpm.take(Ralias, 0);
- T0:=algebra.select(R0,0,100);
+ bpm.open();
+ Ralias:= bpm.take("myversion",:bat[:oid,:int]); # get the partition alias
+ [EMAIL PROTECTED]:oid,hhigh=nil:oid,tlow=nil:int,[EMAIL PROTECTED]:=
bpm.take(Ralias, 0);
+ T0:=algebra.select(R0,0,100);
- [EMAIL PROTECTED]:oid,hhigh=nil:oid,tlow=101,[EMAIL PROTECTED]:=
bpm.take(Ralias, 1);
- T1:= algebra.select(R1,0,100);
+ [EMAIL PROTECTED]:oid,hhigh=nil:oid,tlow=101,[EMAIL PROTECTED]:=
bpm.take(Ralias, 1);
+ T1:= algebra.select(R1,0,100);
- [EMAIL PROTECTED]:oid,hhigh=nil:oid,tlow=201,thigh=nil:[EMAIL
PROTECTED]:= bpm.take(Ralias, 2);
- R:= mat.new(T0,T1,T2);
- T2:=algebra.select(R2,0,100);
+ [EMAIL PROTECTED]:oid,hhigh=nil:oid,tlow=201,thigh=nil:[EMAIL PROTECTED]:=
bpm.take(Ralias, 2);
+ R:= mat.new(T0,T1,T2);
+ T2:=algebra.select(R2,0,100);
@end example
@- Partition iterators
The default strategy for an optimizer is to replace a
reference to a partitioned BAT by an iterator.
@example
- l:= bpm.new();
+ l:= bpm.new();
barrier Elm:bat[:oid,:int]:= bpm.newIterator(Ralias);
- t:= algebra.select(Elm,0,20);
- bpm.addPartition(l,t);
- redo Elm:bat[:oid,:int]:= bpm.newIterator(Ralias);
+ t:= algebra.select(Elm,0,20);
+ bpm.addPartition(l,t);
+ redo Elm:bat[:oid,:int]:= bpm.newIterator(Ralias);
exit Elm;
@end example
Variations on this theme are iterators that search for
@@ -217,7 +217,7 @@
The select operation can be overloaded in the BPM to
improve processing further. For example, the operation
@example
- t := bpm.select(Ralias,0,100);
+ t := bpm.select(Ralias,0,100);
@end example
extracts portions of all three partitions and creates
a non-partitioned result BAT.
@@ -240,19 +240,19 @@
command open():void
address BPMopen
-comment "Locate and open the BAT partition box";
+comment "Locate and open the BAT partition box.";
command close():void
address BPMclose
-comment "Save and close the BAT partition box ";
+comment "Save and close the BAT partition box.";
command destroy():void
address BPMdestroy
-comment "Destroy the BAT partition box";
+comment "Destroy the BAT partition box.";
command deposit(nme:str,b:bat[:oid,:any_2]) :bat[:oid,:any_2]
address BPMdeposit
-comment "Create a new partitioned BAT by name";
+comment "Create a new partitioned BAT by name.";
@-
Temporary results can be administered as partitioned tables as well.
@@ -260,33 +260,33 @@
@mal
pattern new(ht:any_1,tt:any_2):bat[:any_1,:any_2]
address BPMnew
-comment "Create a temporary partitioned table";
+comment "Create a temporary partitioned table.";
command fold(b:bat[:any_1,:any_2]):bat[:any_1,:any_2]
address BPMfold
-comment "Collapse the partitioned BAT into a single BAT";
+comment "Collapse the partitioned BAT into a single BAT.";
command unfold(alias:bat[:any_1,:any_2]) :bat[:any_1,:any_2]
address BPMunfold
-comment "Unfold a BAT into a partitioned one";
+comment "Unfold a BAT into a partitioned one.";
command garbage(b:bat[:any_1,:any_2]):void
address BPMgarbage
-comment "Remove a temporary partitioned table";
+comment "Remove a temporary partitioned table.";
command pieces(b:bat[:any_1,:any_2]):int
address BPMpieces
-comment "Count the number of partitions";
+comment "Count the number of partitions.";
command count(b:bat[:any_1,:any_2]):int
address BPMcount;
command emptySet(b:bat[:any_1,:any_2]):void
address BPMemptySet
-comment "Implement the constraints test efficiently";
+comment "Implement the empty set constraints test efficiently.";
command sortTail(b:bat[:any_1,:any_2]):bat[:any_1,:any_2]
address BPMsortTail
-comment "Implement the sort on tail for partitioned BAT efficiently";
+comment "Implement the sort on tail for partitioned BAT efficiently.";
@-
The partitioning is handled inside the module.
If the alias BAT denotes an existing partition, it is
@@ -294,38 +294,38 @@
@mal
command rangePartition(pb:bat[:any_1,:any_2], rl:any_2, rh:any_2):void
address BPMrange
-comment "Create a range partition on a BAT";
+comment "Create a range partition on a BAT.";
command rangePartition(pb:bat[:any_1,:any_2], pv:bat[:oid,:any_2]):void
address BPMrangeVector
-comment "Create the partitions based on a range vector";
+comment "Create the partitions based on a range vector.";
command rangePartitionSort(pb:bat[:any_1,:any_2], pv:bat[:oid,:any_2]):void
address BPMrangeVectorSort
-comment "Create the partitions based on a range vector";
+comment "Create the partitions based on a range vector.";
command sortPartitions(b:bat[:any_1,:any_2]):void
address BPMsortPartitions
-comment "Sort all partitions of alias b on the tail";
+comment "Sort all partitions of alias b on the tail.";
command hashPartitions(b:bat[:any_1,:any_2]):void
address BPMhashPartitions
-comment "Ensure all partitions have a hash in the head";
+comment "Ensure all partitions have a hash in the head.";
command partition(pb:bat[:any_1,:any_2], val:any_2):void
address BPMsplitpartition
-comment "Split all partitions that cover the split value";
+comment "Split all partitions that cover the split value.";
command addPartition(b:bat[:any_1,:any_2],s:bat[:any_1,:any_2]):void
address BPMaddPartition
-comment "Add a partition to a fragmented temporary table";
+comment "Add a partition to a fragmented temporary table.";
command addPartition(b:bat[:any_1,:any_2],s:BAT):void
address BPMaddPartition
-comment "Add a partition to a fragmented temporary table";
+comment "Add a partition to a fragmented temporary table.";
command hashPartition(pb:bat[:any_1,:any_2], slots:int):void
address BPMhash
-comment "Create a hash partition on a BAT";
+comment "Create a hash partition on a BAT.";
command derivePartition(pb:bat[:any_1,:any_2],
src:bat[:any_1,:any_2]):bat[:any_1,:any_2]
address BPMderived
@@ -333,45 +333,45 @@
command adapt(s:bat[:any_1,:any_2], low:any_2, hgh:any_2,
rs:bat[:any_1,:any_3], pol:int) :bat[:any_1,:any_2]
address BPMadapt
-comment "Re-organize segment s using the selection (val1,val2) stored in bat
rs";
+comment "Re-organize segment s using the selection (val1,val2) stored in bat
rs.";
command take(pb:int):bat[:any_1,:any_2]
address BPMtakeIndexed
-comment "Retrieve the partition given the its index ";
+comment "Retrieve the partition given the its index.";
command take(pb:str):bat[:any_1,:any_2]
address BPMtake
-comment "Retrieve the alias given the name of a partitioned BAT";
+comment "Retrieve the alias given the name of a partitioned BAT.";
command take(nme:str, hl:any_1, hh:any_1, tl:any_2, th:any_2)
:bat[:any_1,:any_2]
address BPMtakePartition
-comment "Retrieve a single component of a partitioned BAT by index";
+comment "Retrieve a single component of a partitioned BAT by index.";
command take(nme:bat[:any_1,:any_2],idx:int, hl:any_1, hh:any_1, tl:any_2,
th:any_2) :bat[:any_1,:any_2]
address BPMtakePartitionIndexed
-comment "Retrieve a single component of a partitioned BAT by index";
+comment "Retrieve a single component of a partitioned BAT by index.";
command insert(pb:bat[:any_1,:any_2],b:bat[:any_1,:any_2]) :void
address BPMinsert
-comment "Insert elements into the BAT partitions";
+comment "Insert elements into the BAT partitions.";
command delete(pb:bat[:any_1,:any_2],b:bat[:any_1,:any_2]) :void
address BPMdelete
-comment "Delete elements from the BAT partitions";
+comment "Delete elements from the BAT partitions.";
command replace(pb:bat[:any_1,:any_2],old:bat[:any_1,:any_2],
nwe:bat[:any_1,:any_2]) :void
address BPMreplace
-comment "Replace the content of the BAT partitions";
+comment "Replace the content of the BAT partitions.";
command getNames():bat[:oid,:str]
address BPMgetNames
-comment "Retrieve the names of all known partitioned BATs";
+comment "Retrieve the names of all known partitioned BATs.";
command discard(alias:bat[:any_1,:any_2]) :void
address BPMdiscard
-comment "Release a partitioned BAT from the box";
+comment "Release a partitioned BAT from the box.";
command discard() :void
address BPMdiscardAll
-comment "Release all partitioned BATs";
+comment "Release all partitioned BATs.";
@-
In most situations we would like to iterator over
Index: box.mx
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/modules/mal/box.mx,v
retrieving revision 1.34
retrieving revision 1.35
diff -u -d -r1.34 -r1.35
--- box.mx 11 Jan 2008 10:41:37 -0000 1.34
+++ box.mx 10 Feb 2008 23:48:47 -0000 1.35
@@ -40,7 +40,7 @@
comment "Destroy the box.";
pattern take(bnme:str, vnme:str):any_1
address BOXtake
-comment "Locates the typed value in the box.";
+comment "Locate the typed value in the box.";
pattern deposit(bname:str,name:str,v:any_1):void
address BOXdeposit
comment "Enter a new value into the box.";
Index: bbp.mx
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/modules/mal/bbp.mx,v
retrieving revision 1.117
retrieving revision 1.118
diff -u -d -r1.117 -r1.118
--- bbp.mx 11 Jan 2008 10:41:37 -0000 1.117
+++ bbp.mx 10 Feb 2008 23:48:47 -0000 1.118
@@ -30,7 +30,7 @@
Any BAT B created can be brought under this scheme with the name N.
The association N->B is only maintained in the box administration
and not reflected in the BAT descriptor.
-In particular, taking a BATobject out of the box leads to a private
+In particular, taking a BAT object out of the box leads to a private
copy to isolate the user from concurrent updates on the underlying store.
Upon releasing it, the updates are merged with the master copy [todo].
@@ -51,7 +51,7 @@
comment "Destroy the box";
pattern take(name:str) :bat[:any_1,:any_2]
address CMDbbptake
-comment "Load a particular bat";
+comment "Load a particular bat.";
pattern deposit(name:str,v:bat[:any_1,:any_2]) :void
address CMDbbpdeposit
comment "Enter a new bat into the bbp box.";
@@ -60,10 +60,10 @@
comment "Relate a logical name to a physical BAT in the buffer pool.";
pattern commit():void
address CMDbbpReleaseAll
-comment "Commit updates for this client";
+comment "Commit updates for this client.";
pattern releaseAll():void
address CMDbbpReleaseAll
-comment "Commit updates for this client";
+comment "Commit updates for this client.";
pattern release(name:str,val:bat[:any_1,:any_2]) :void
address CMDbbprelease
comment "Commit updates and release this BAT.";
@@ -72,24 +72,24 @@
comment "Remove the BAT from further consideration";
pattern destroy(b:bat[:any_1,:any_2]):void
address CMDbbpdestroyBAT1
-comment "BAT removal at session end";
+comment "Schedule a BAT for removal at session end.";
pattern destroy(b:bat[:any_1,:any_2],immediate:bit)
address CMDbbpdestroyBAT
-comment "Schedule a BAT for removal at session end or immediately";
+comment "Schedule a BAT for removal at session end or immediately.";
pattern toString(name:str):str
address CMDbbptoStr
-comment "Get the string representation of an element in the box";
+comment "Get the string representation of an element in the box.";
pattern discard(name:str):void
address CMDbbpdiscard
-comment "Remove the BAT from the box";
+comment "Remove the BAT from the box.";
pattern iterator(nme:str):lng
address CMDbbpiterator
-comment "Locates the next element in the box";
+comment "Locate the next element in the box.";
pattern prelude():void
address CMDbbpprelude
-comment "Initialize the bbp box";
+comment "Initialize the bbp box.";
pattern bind(name:str):bat[:any_1,:any_2]
address CMDbbpbind
@@ -176,7 +176,7 @@
comment "Utility for debugging MAL interpreter";
command getDiskSpace() :int
address CMDbbpDiskSpace
-comment "Estimate the amount of diskspace occupied by dbfarm";
+comment "Estimate the amount of disk space occupied by dbfarm";
@-
@{
@include prelude.mx
Index: mal_mapi.mx
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/modules/mal/mal_mapi.mx,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- mal_mapi.mx 28 Jan 2008 08:00:18 -0000 1.3
+++ mal_mapi.mx 10 Feb 2008 23:48:50 -0000 1.4
@@ -40,10 +40,10 @@
comment "Start a Mapi server with the default settings.";
command listen(port:int):int
address SERVERlisten_port
-comment "Start a Mapi server on the given port";
+comment "Start a Mapi listener on the port given.";
command listen(port:int, maxusers:int):int
address SERVERlisten2
-comment "Start a Mapi server";
+comment "Start a Mapi listener.";
command listen(port:int, maxusers:int, cmd:str):int
address SERVERlisten3
@@ -62,73 +62,73 @@
command stop():void
address SERVERstop
-comment "Terminate connection listeners";
+comment "Terminate connection listeners.";
command suspend():void
address SERVERsuspend
-comment "Suspend accepting connections";
+comment "Suspend accepting connections.";
command resume():void
address SERVERresume
-comment "Resume connection listeners";
+comment "Resume connection listeners.";
command malclient(in:streams, out:streams):void
address SERVERclient
-comment "Start a Mapi client.";
+comment "Start a Mapi client for a particular stream pair.";
command trace(mid:int,flag:int):void
address SERVERtrace
-comment "Toggle the Mapi library tracer";
+comment "Toggle the Mapi library debug tracer.";
command reconnect(host:str, port:int, usr:str, passwd:str,lang:str):int
address SERVERreconnectWithoutAlias
-comment "Re-establish connection with a remote mserver";
+comment "Re-establish connection with a remote mserver.";
command reconnect(host:str, port:int, db_alias:str, usr:str,
passwd:str,lang:str):int
address SERVERreconnectAlias
-comment "Re-establish connection with a remote mserver";
+comment "Re-establish connection with a remote mserver.";
command reconnect(mid:int):void
address SERVERreconnect
-comment "Re-establish a connection";
+comment "Re-establish a connection.";
command connect(host:str, port:int, usr:str, passwd:str,lang:str):int
address SERVERconnect
-comment "Establish connection with a remote mserver";
+comment "Establish connection with a remote mserver.";
command connect_ssl(host:str, port:int, usr:str, passwd:str,lang:str):int
address SERVERconnectssl
comment "Establish connection with a remote mserver using the
-secure socket layer";
+secure socket layer.";
command disconnect(dbalias:str):int
address SERVERdisconnectWithAlias
-comment "Close connection with a remote mserver";
+comment "Close connection with a remote Mserver.";
command disconnect():int
address SERVERdisconnectALL
-comment "Close connections with all remote mserver";
+comment "Close connections with all remote Mserver.";
command setAlias(dbalias:str)
address SERVERsetAlias
-comment "Give the channel a logical name";
+comment "Give the channel a logical name.";
command lookup(dbalias:str):int
address SERVERlookup
-comment "Retrieve the connection identifier";
+comment "Retrieve the connection identifier.";
command disconnect(mid:int):void
address SERVERdisconnect
-comment "Terminate the session";
+comment "Terminate the session.";
command destroy(mid:int):void
address SERVERdestroy
-comment "Destroy the handle";
+comment "Destroy the handle for an Mserver.";
command ping(mid:int):int
address SERVERping
-comment "Test availability of server";
+comment "Test availability of an Mserver.";
command query(mid:int, qry:str):int
address SERVERquery
@@ -136,75 +136,75 @@
command query_handle(mid:int, qry:str):int
address SERVERquery_handle
-comment "Sent the query for execution";
+comment "Sent the query for execution.";
pattern query_array(mid:int, qry:str, arg:str...):int
address SERVERquery_array
-comment "Sent the query for execution replacing '?' by arguments";
+comment "Sent the query for execution replacing '?' by arguments.";
command prepare(mid:int, qry:str):int
address SERVERprepare
-comment "Prepare a query for execution";
+comment "Prepare a query for execution.";
command finish(hdl:int):int
address SERVERfinish
-comment "Remove all remaining answers";
+comment "Remove all remaining answers.";
command get_field_count(hdl:int):int
address SERVERget_field_count
-comment "Return number of fields";
+comment "Return number of fields.";
command get_row_count(hdl:int):int
address SERVERget_row_count
-comment "Return number of rows";
+comment "Return number of rows.";
command fetch_row(hdl:int):int
address SERVERrows_affected
-comment "Return number of affected rows";
+comment "Return number of affected rows.";
command fetch_row(hdl:int):int
address SERVERfetch_row
-comment "Retrieve the next row for analysis";
+comment "Retrieve the next row for analysis.";
command fetch_all_rows(hdl:int):int
address SERVERfetch_all_rows
-comment "Retrieve all rows into the cache";
+comment "Retrieve all rows into the cache.";
command fetch_field(hdl:int,fnr:int):str
address SERVERfetch_field_str
-comment "Retrieve a single field";
+comment "Retrieve a single field.";
command fetch_field(hdl:int,fnr:int):int
address SERVERfetch_field_int
-comment "Retrieve a single int field";
+comment "Retrieve a single int field.";
command fetch_field(hdl:int,fnr:int):lng
address SERVERfetch_field_lng
-comment "Retrieve a single lng field";
+comment "Retrieve a single lng field.";
command fetch_field(hdl:int,fnr:int):sht
address SERVERfetch_field_sht
-comment "Retrieve a single sht field";
+comment "Retrieve a single sht field.";
command fetch_field(hdl:int,fnr:int):void
address SERVERfetch_field_void
-comment "Retrieve a single void field";
+comment "Retrieve a single void field.";
command fetch_field(hdl:int,fnr:int):oid
address SERVERfetch_field_oid
-comment "Retrieve a single void field";
+comment "Retrieve a single void field.";
command fetch_field(hdl:int,fnr:int):chr
address SERVERfetch_field_chr
-comment "Retrieve a single chr field";
+comment "Retrieve a single chr field.";
command fetch_field_array(hdl:int):bat[:int,:str]
address SERVERfetch_field_bat
-comment "Retrieve all fields for a row";
+comment "Retrieve all fields for a row.";
command fetch_line(hdl:int):str
address SERVERfetch_line
-comment "Retrieve a complete line";
+comment "Retrieve a complete line.";
command fetch_reset(hdl:int):int
address SERVERfetch_reset
@@ -212,50 +212,50 @@
command next_result(hdl:int):int
address SERVERnext_result
-comment "Go to next result set";
+comment "Go to next result set.";
command error(mid:int):int
address SERVERerror
-comment "Check for an error in the communication";
+comment "Check for an error in the communication.";
command getError(mid:int):str
address SERVERgetError
-comment "Get error message";
+comment "Get error message.";
command explain(mid:int):str
address SERVERexplain
-comment "Turn the error seen into a string";
+comment "Turn the error seen into a string.";
pattern put(mid:int, nme:str, val:any_1):void
address SERVERput
-comment "Send a value to a remote site";
+comment "Send a value to a remote site.";
pattern put(nme:str, val:any_1):str
address SERVERputLocal
-comment "Prepare sending a value to a remote site";
+comment "Prepare sending a value to a remote site.";
pattern rpc(key:int,qry:str...):any
address SERVERmapi_rpc_single_row
-comment "Sent a simple query for execution and fetch result";
+comment "Sent a simple query for execution and fetch result.";
pattern rpc(key:int,qry:str):bat[:any_1,:any_2]
address SERVERmapi_rpc_bat;
command rpc(key:int,qry:str):void
address SERVERquery
-comment "Sent a simple query for execution";
+comment "Sent a simple query for execution.";
pattern
bind(key:int,rschema:str,rtable:str,rcolumn:str,i:int):bat[:any_1,:any_2]
address SERVERbindBAT
-comment "Bind a remote variable to a local one";
+comment "Bind a remote variable to a local one.";
pattern bind(key:int,rschema:str,rtable:str,i:int):bat[:any_1,:any_2]
address SERVERbindBAT
-comment "Bind a remote variable to a local one";
+comment "Bind a remote variable to a local one.";
pattern bind(key:int,remoteName:str):bat[:any_1,:any_2]
address SERVERbindBAT
-comment "Bind a remote variable to a local one";
+comment "Bind a remote variable to a local one.";
mapi.listen();
Index: fleet.mx
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/modules/mal/fleet.mx,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -d -r1.9 -r1.10
--- fleet.mx 11 Jan 2008 10:41:37 -0000 1.9
+++ fleet.mx 10 Feb 2008 23:48:50 -0000 1.10
@@ -184,7 +184,7 @@
command registry(name:str,port:nr)
address FLEETregistry
comment "Take upon you to act as a localhost registry and listen
-to requests to join/leave";
+to requests to join/leave.";
command join(nme:str, host:str, port:nr): str
address FLEETjoin
@@ -193,22 +193,22 @@
within the fleet.";
command leave(alias:str)
-comment "Leave the fleet of servers for which you have an alias";
+comment "Leave the fleet of servers for which you have an alias.";
command members(name:str):bat[:oid,:str]
-comment "Produce the alias member list of a fleet";
+comment "Produce the alias member list of a fleet.";
pattern put(alias:int, nme:str, val:any_1):void
address FLEETput
-comment "Send a value to a remote site";
+comment "Send a value to a remote site.";
pattern put(nme:str, val:any_1):str
address FLEETputLocal
-comment "Prepare sending a value to a remote site";
+comment "Prepare sending a value to a remote site.";
pattern rpc(key:int,qry:str...):any
address FLEETmapi_rpc_single_row
-comment "Sent a simple query for execution and fetch result";
+comment "Sent a simple query for execution and fetch result.";
pattern rpc(key:int,qry:str):bat[:any_1,:any_2]
address FLEETmapi_rpc_bat;
@@ -219,15 +219,15 @@
pattern
bind(key:int,rschema:str,rtable:str,rcolumn:str,i:int):bat[:any_1,:any_2]
address FLEETbindBAT
-comment "Bind a remote variable to a local one";
+comment "Bind a remote variable to a local one.";
pattern bind(key:int,rschema:str,rtable:str,i:int):bat[:any_1,:any_2]
address FLEETbindBAT
-comment "Bind a remote variable to a local one";
+comment "Bind a remote variable to a local one.";
pattern bind(key:int,remoteName:str):bat[:any_1,:any_2]
address FLEETbindBAT
-comment "Bind a remote variable to a local one";
+comment "Bind a remote variable to a local one.";
@-
@{
Index: batExtensions.mx
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/modules/mal/batExtensions.mx,v
retrieving revision 1.20
retrieving revision 1.21
diff -u -d -r1.20 -r1.21
--- batExtensions.mx 11 Jan 2008 10:41:37 -0000 1.20
+++ batExtensions.mx 10 Feb 2008 23:48:46 -0000 1.21
@@ -32,7 +32,7 @@
pattern bat.new(ht:any_1, tt:any_2, b:bat[:any_3,:any_4]) :bat[:any_1,:any_2]
address CMDBATclone
-comment "Creates a new empty transient BAT by cloning another";
+comment "Creates a new empty transient BAT by cloning another.";
pattern bat.new(ht:any_1, tt:any_2) :bat[:any_1,:any_2]
address CMDBATnew
comment "Creates a new empty transient BAT,
@@ -54,28 +54,28 @@
address CMDBATnewDerived;
command bat.new(nme:str):bat[:any_1,:any_2]
address CMDBATderivedByName
-comment "Localize a bat by name and produce a variant";
+comment "Localize a bat by name and produce a clone.";
command bat.reduce(b:bat[:any_1,:any_2]):bat[:any_1,:any_2]
address CMDBATreduce
-comment "Designate a BAT for which auxillary structures can be dropped";
+comment "Drop auxillary BAT structures.";
command bat.flush(b:bat[:any_1,:any_2]):void
address CMDBATflush
-comment "Designate a BAT as not needed anymore";
+comment "Designate a BAT as not needed anymore.";
pattern bat.setGarbage(b:bat[:any_1,:any_2]):void
address CMDBATsetGarbage
-comment "Designate a BAT as garbage";
+comment "Designate a BAT as garbage.";
pattern bat.unpack(b:bat[:any_1,:any_2])(h:any_1,t:any_2)
address CMDbatunpack
-comment "Extract the first tuple from a bat";
+comment "Extract the first tuple from a BAT.";
pattern bat.pack(h:any_1,t:any_2):bat[:any_1,:any_2]
address CMDbatpack
-comment "Pack a pair into a BAT";
+comment "Pack a pair of values into a BAT.";
pattern bat.setBase(b:bat[:any_1,:any_2],c:bat[:any_1,:any_2]...):void
address CMDsetBase
-comment "Give the non-empty BATs consecutive oid bases";
+comment "Give the non-empty BATs consecutive oid bases.";
@{
@{
Index: algebraExtensions.mx
===================================================================
RCS file: /cvsroot/monetdb/MonetDB5/src/modules/mal/algebraExtensions.mx,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -d -r1.10 -r1.11
--- algebraExtensions.mx 11 Jan 2008 10:41:37 -0000 1.10
+++ algebraExtensions.mx 10 Feb 2008 23:48:46 -0000 1.11
@@ -28,7 +28,7 @@
comment "Fill the tail column with a newly typed constant.";
pattern algebra.project(b:bat[:any_1,:any_3], val:bat[:any_1,:any_2])
:bat[:any_1,:any_2]
address ALGprojectCst
-comment "Fill the tail column with a constant.";
+comment "Fill the tail column with a constant taken from the aligned BAT.";
@{
@include prelude.mx
-------------------------------------------------------------------------
This SF.net email is sponsored by: Microsoft
Defy all challenges. Microsoft(R) Visual Studio 2008.
http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
_______________________________________________
Monetdb-checkins mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/monetdb-checkins
