The table below summarizes the commentary lines encountered in
the system associated with a MAL kernel modules.
|
| aggr.avg
| Grouped tail average on dbl
|
| aggr.cardinality
| Return the cardinality of the BAT tail values.
|
| aggr.count
| Grouped count
|
| aggr.count_no_nil
| Return the number of elements currently
in a BAT ignoring BUNs with nil-tail
|
| aggr.histogram
| Produce a BAT containing the histogram over the tail values.
|
| aggr.max
| Give the highest tail value.
|
| aggr.min
| Give the lowest tail value.
|
| aggr.prod
| Gives the product of all tail values.
|
| aggr.product
| Product over grouped tail on dbl
|
| aggr.size
| Grouped count of true values
|
| aggr.sum
| Grouped tail sum on dbl
|
|
| alarm.alarm
| execute action in X secs
|
| alarm.ctime
| current time as a string
|
| alarm.epilogue
| Finalize alarm module
|
| alarm.epoch
| current time as unix epoch
|
| alarm.prelude
| Initialize alarm module
|
| alarm.sleep
| sleep X secs
|
| alarm.time
| time in millisecs
|
| alarm.timers
| give a list of all active timers
|
| alarm.usec
| return cpu microseconds info
|
|
| algebra.antijoin
| Returns the antijoin
|
| algebra.antiuselect
| See select() but limited to head values
|
| algebra.bandjoin
| This is a join() for which the predicate is that two BUNs match
if the left-tail value is within the range [right-head - minus,
right-head + plus], depending on (l_in/h_in), the bounds
are included. Works only for the builtin numerical types,
and their derivates.
|
| algebra.copy
| Returns physical copy of a BAT.
|
| algebra.crossproduct
| Returns the cross product
|
algebra.difference
|
| algebra.exist
| Returns true when 'h,t' occurs as a bun in b.
|
| algebra.fetch
| Returns a positional selection of b by the oid
head values of s
|
| algebra.fetchjoin
| Hook directly into the fetch implementation of the join.
|
| algebra.find
| Returns the tail value 't' for which some [h,t] BUN
exists in b. If no such BUN exists, an error occurs.
|
| algebra.fragment
| Select both on head and tail range.
|
| algebra.groupby
| Produces a new BAT with groups identified by the head column. The result contains tail times the head value, ie the tail contains the result group sizes.
|
| algebra.hashjoin
| Hook directly into the hash implementation of the join.
|
| algebra.hashsplit
| Split a BAT on tail column according (hash-value MOD buckets).
Returns a recursive BAT, containing the fragments in the tail,
their bucket number in the head.
|
| algebra.indexjoin
| Hook directly into the index implementation of the join.
|
algebra.intersect
|
| algebra.join
| Returns all BUNs, consisting of a head-value from 'left' and
a tail-value from 'right' for which there are BUNs in 'left'
and 'right' with equal tail- resp. head-value (i.e. the join
columns are projected out).
|
| algebra.joinPath
| internal routine to handle join paths.
The type analysis is rather tricky.
|
| algebra.kdifference
| Returns the difference taken over only the *head* columns of two BATs.
Results in all BUNs of 'left' that are *not* in 'right'.
It does *not* do double-elimination over the 'left' BUNs.
If you want this, use:
'kdifference(left.kunique,right.kunique)'
or: 'kdifference(left,right).kunique'.
|
| algebra.kintersect
| Returns the intersection taken over only the *head* columns of two BATs.
Results in all BUNs of 'left' that are also in 'right'.
Does *not* do double- elimination over the 'left' BUNs.
If you want this, use: 'kintersect(kunique(left),kunique(right))'
or: 'kunique(kintersect(left,right))'.
|
| algebra.kunion
| Returns the union of two BATs; looking at head-columns only.
Results in all BUNs of 'left' that are not in 'right', plus
all BUNs of 'right'. *no* double-elimination is done.
If you want this, do:
'kunion(left.kunique,right.kunique)'
or: 'sunion(left,right).kunique'.
|
| algebra.kunique
| Select unique tuples from the input BAT. Double elimination is
done only looking at the head column. The result is a BAT with
property hkeyed() == true.
|
algebra.leftfetchjoin
|
| Hook directly into the left fetch join implementation.
|
algebra.leftjoin
|
| algebra.like
| Selects all elements that have 'substr' as in the tail.
|
| algebra.markH
| Produces a new BAT with fresh unique dense sequense of OIDs in
the head that starts at base (i.e. [base,..base+b.count()-1] ).
|
| algebra.markT
| Produces a BAT with fresh unique OIDs in the tail starting at 0@0.
|
| algebra.mark_grp
| "grouped mark": Produces a new BAT with per group a locally unique dense
ascending sequense of OIDs in the tail. The tail of the first BAT (b)
identifies the group that each BUN of b belongs to. The second BAT (g)
represents the group extend, i.e., the head is the unique list of group IDs
from b's tail. The third argument (s) gives the base value for the new
OID sequence of each group.
|
| algebra.materialize
| Materialize the void column
|
| algebra.merge
| Merge head and tail into a single value
|
| algebra.mergejoin
| Hook directly into the merge implementation of the join.
|
| algebra.number
| Produces a new BAT with identical head column, and consecutively
increasing integers (start at 0) in the tail column.
|
| algebra.outerjoin
| Returns all the result of a join, plus the BUNS formed NIL in
the tail and the head-values of 'outer' whose tail-value does
not match an head-value in 'inner'.
|
| algebra.position
| Returns the position of the value pair It returns an
error if 'val' does not exist.
|
| algebra.project
| Fill the tail column with a constant taken from the aligned BAT.
|
| algebra.rangesplit
| Split a BAT on tail column in 'ranges' equally sized consecutive
ranges. Returns a recursive BAT, containing the fragments in the tail,
the higher-bound of the range in the head. The higher bound of the last
range is 'nil'.
|
| algebra.reuse
| Reuse a temporary BAT if you can. Otherwise,
allocate enough storage to accept result of an
operation (not involving the heap)
|
| algebra.revert
| Returns a BAT copy with buns in reverse order
|
| algebra.sample
| Produce a random selection of size 'num' from the input BAT.
|
| algebra.sdifference
| Returns the difference taken over *both* columns of two BATs.
Results in all BUNs of 'left' that are *not* in 'right'.
Does *not* do double-elimination over the 'left' BUNs.
If you want this, use:
'sdifference(left.sunique,right.sunique)'
or: 'sdifference(left,right).sunique'.
|
| algebra.select
| Select all BUNs of a BAT with a certain
tail value. Selection on NIL is also
possible (it should be properly casted,
e.g.:int(nil)).
|
algebra.selectH
|
| algebra.selectNotNil
| Select all not-nil values
|
| algebra.semijoin
| Returns the intersection taken over only the *head* columns of
two BATs. Results in all BUNs of 'left' that are also in 'right'.
Does *not* do double-elimination over the 'left' BUNs.
If you want this, use: 'kintersect(kunique(left),kunique(right))'
or: 'kunique(kintersect(left,right))'.
|
| algebra.sintersect
| Returns the intersection taken over *both* columns of two BATs.
Results in all BUNs of 'left' that are also in 'right'. Does *not*
do double-elimination over the 'left' BUNs, If you want this, use:
'sintersect(sunique(left),sunique(right))'
or: 'sunique(sintersect(left,right))'.
|
| algebra.slice
| Return the slice with the BUNs at position x till y.
|
| algebra.sort
| Returns a BAT copy sorted on the head column.
|
| algebra.sortHT
| Returns a lexicographically sorted copy on head,tail.
|
| algebra.sortReverse
| Returns a BAT copy reversely sorted on the tail column.
|
algebra.sortReverseTail
|
| Returns a BAT copy reversely sorted on the tail column.
|
| algebra.sortTH
| Returns a lexicographically sorted copy on tail,head.
|
| algebra.sortTail
| Returns a BAT copy sorted on the tail column.
|
| algebra.split
| Split head into two values
|
| algebra.ssort
| Returns copy of a BAT with the BUNs sorted on ascending head values.
This is a stable sort.
|
| algebra.ssort_rev
| Returns copy of a BAT with the BUNs sorted on descending head values.
This is a stable sort.
|
| algebra.sunion
| Returns the union of two BATs; looking at both columns of both BATs.
Results in all BUNs of 'left' that are not in 'right', plus all
BUNs of 'right'. *no* double-elimination is done.
If you want this, do:
'sunion(left.sunique,right.sunique)'
or: 'sunion(left,right).sunique'.
|
| algebra.sunique
| Select unique tuples from the input BAT. Double elimination is
done over BUNs as a whole (head and tail). Result is a BAT
with real set() semantics.
|
| algebra.thetajoin
| Theta join on for 'mode' in { LE, LT, EQ, GT, GE }. JOIN_EQ is
just the same as join(). All other options do merge algorithms.
Either using the fact that they are ordered() already (left on tail,
right on head), or by using/creating binary search trees on the
join columns.
|
| algebra.thetaselect
| The theta (<=,<,=,>,>=) select()
|
| algebra.thetauselect
| The theta (<=,<,=,>,>=) select() limited to head values
|
| algebra.topN
| Trim all but the top N tuples.
|
| algebra.tunique
| Select unique tuples from the input BAT. Double elimination is
done over the BUNs tail. The result is a BAT with property
tkeyd()== true
|
| algebra.uhashsplit
| Same as hashsplit, but only collect the head values in the fragments
|
algebra.union
|
algebra.unique
|
| algebra.urangesplit
| Same as rangesplit, but only collect the head values in the fragments
|
| algebra.uselect
| Value select, but returning only the
head values. SEE ALSO:select(bat,val)
|
|
| array.grid
| Fills an index BAT, (grpcount,grpsize,clustersize,offset)
and shift all elemenets with a factor s
|
| array.product
| Produce an array product
|
| array.project
| Fill an array representation with constants
|
|
| bat.append
| append the value u to i
|
| bat.attach
| Returns a new BAT with dense head and tail of the given type and uses
the given file to initialize the tail. The file will be owned by the
server.
|
| bat.delete
| Delete from the first BAT all BUNs with a corresponding BUN
in the second.
|
| bat.densebat
| Creates a new [void,void] BAT of size 'size'.
|
| bat.flush
| Designate a BAT as not needed anymore.
|
| bat.getAccess
| return the access mode attached to this BAT as a character.
|
| bat.getAlpha
| Obtain the list of BUNs added
|
| bat.getCapacity
| Returns the current allocation size (in max number of elements) of a BAT.
|
| bat.getDelta
| Obtain the list of BUNs deleted
|
| bat.getDiskSize
| Approximate size of the (persistent) BAT heaps as stored on disk
in pages of 512 bytes. Indices are not included, as they only live temporarily
in virtual memory.
|
| bat.getHead
| return the BUN head value using the cursor.
|
| bat.getHeadType
| Returns the type of the head column of a BAT, as an integer type number.
|
| bat.getHeat
| Return the current BBP heat (LRU stamp)
|
| bat.getMemorySize
| Calculate the size of the BAT heaps and indices in bytes
rounded to the memory page size (see bbp.getPageSize()).
|
| bat.getName
| Gives back the logical name of a BAT.
|
| bat.getRole
| Returns the rolename of the head column of a BAT.
|
| bat.getSequenceBase
| Get the sequence base for the void column of a BAT.
|
| bat.getSize
| Calculate the size of the BAT descriptor, heaps and indices in bytes.
|
| bat.getSpaceUsed
| Determine the total space (in bytes) occupied by a BAT.
|
| bat.getStorageSize
| Determine the total space (in bytes) reserved for a BAT.
|
| bat.getTail
| return the BUN tail value using the cursor.
|
| bat.getTailType
| Returns the type of the tail column of a BAT, as an integer type number.
|
| bat.hasAppendMode
| return true if to this BAT is append only.
|
| bat.hasMoreElements
| Produce the next bun for processing.
|
| bat.hasReadMode
| return true if to this BAT is read only.
|
| bat.hasWriteMode
| return true if to this BAT is read and write.
|
| bat.info
| Produce a BAT containing info about a BAT in [attribute,value] format.
It contains all properties of the BAT record. See the BAT documentation
in GDK for more information.
|
| bat.inplace
| inplace replace values on the given locations
|
| bat.insert
| Insert one BUN[h,t] in a BAT.
|
| bat.isCached
| Bat is stored in main memory.
|
bat.isPersistent
|
| bat.isSorted
| Returns whether a BAT is ordered on head or not.
|
| bat.isSortedReverse
| Returns whether a BAT is ordered on head or not.
|
| bat.isSynced
| Tests whether two BATs are synced or not.
|
bat.isTransient
|
| bat.isaKey
| return whether the head column of a BAT is unique (key).
|
| bat.isaSet
| return whether the BAT mode is set to unique.
|
| bat.load
| Load a particular BAT from disk
|
| bat.mirror
| Returns the head-mirror image of a BAT (two head columns).
|
| bat.new
| Localize a bat by name and produce a clone.
|
| bat.newIterator
| Process the buns one by one extracted from a void table.
|
| bat.order
| Sorts the BAT itself on the head, in place.
|
| bat.orderReverse
| Reverse sorts the BAT itself on the head, in place.
|
| bat.pack
| Pack a pair of values into a BAT.
|
| bat.partition
| Create a series of cheap slices over the first argument
|
| bat.reduce
| Drop auxillary BAT structures.
|
| bat.replace
| Replace the tail value of one BUN that has some head value.
|
| bat.reverse
| Returns the reverse view of a BAT (head is tail and tail is head).
BEWARE no copying is involved; input and output refer to the
same object!
|
| bat.revert
| Puts all BUNs in a BAT in reverse order. (Belongs to the
BAT sequence module)
|
| bat.save
| Save a BAT to storage, if it was loaded and dirty.
Returns whether IO was necessary. Please realize that
calling this function violates the atomic commit protocol!!
|
| bat.setAccess
| Try to change the update access priviliges
to this BAT. Mode:
r[ead-only] - allow only read access.
a[append-only] - allow reads and update.
w[riteable] - allow all operations.
BATs are updatable by default. On making a BAT read-only,
all subsequent updates fail with an error message.Returns
the BAT itself.
|
| bat.setAppendMode
| Change access privilige of BAT to append only
|
| bat.setBase
| Give the non-empty BATs consecutive oid bases.
|
| bat.setCold
| Makes a BAT very cold for the BBP. The chance of being choses
for swapout is big, afterwards.
|
| bat.setColumn
| Give both columns of a BAT a new name.
|
| bat.setGarbage
| Designate a BAT as garbage.
|
bat.setHash
|
| bat.setHot
| Makes a BAT very hot for the BBP. The chance of being chosen for
swapout is small, afterwards.
|
| bat.setKey
| 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;
|
| bat.setMemoryAdvise
| alias for madvise(b, mode, mode, mode, mode)
|
| bat.setMemoryMap
| Alias for mmap(b, mode, mode, mode, mode)
|
| bat.setName
| Give a logical name to a BAT.
|
| bat.setPersistent
| Make the BAT persistent. Returns boolean which indicates
if the BAT administration has indeed changed.
|
| bat.setReadMode
| Change access privilige of BAT to read only
|
| bat.setRole
| Give a logical name to the columns of a BAT.
|
| bat.setSet
| 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.
|
| bat.setSorted
| Assure BAT is ordered on the head.
|
| bat.setTransient
| Make the BAT transient. Returns
boolean which indicates if the
BAT administration has indeed changed.
|
| bat.setWriteMode
| Change access privilige of BAT to read and write
|
| bat.unload
| Swapout a BAT to disk. Transient BATs can also be swapped out.
Returns whether the unload indeed happened.
|
| bat.unpack
| Extract the first tuple from a BAT.
|
|
| batcalc.!=
| Equate a bat of strings against a singleton
|
| batcalc.%
| Binary BAT calculator function with new BAT result
|
| batcalc.*
| Binary BAT calculator function with new BAT result
|
| batcalc.+
| Concatenate two strings.
|
| batcalc.++
| Unary minus over the tail of the bat
|
| batcalc.-
| Unary minus over the tail of the bat
|
| batcalc.–
| Unary minus over the tail of the bat
|
| batcalc./
| Binary BAT calculator function with new BAT result
|
| batcalc.<
| Compare a bat of timestamp against a singleton
|
| batcalc.<=
| Compare a bat of timestamp against a singleton
|
| batcalc.==
| Equate a bat of strings against a singleton
|
| batcalc.>
| Compare a bat of timestamp against a singleton
|
| batcalc.>=
| Compare a bat of timestamp against a singleton
|
| batcalc.abs
| Unary abs over the tail of the bat
|
| batcalc.and
| Binary BAT calculator function with new BAT result
|
| batcalc.bit
| Coerce an str tail to a bat with bit tail.
|
| batcalc.bte
| Coerce an bit tail to a bat with bte tail.
|
batcalc.chr
|
| batcalc.dbl
| Coerce an flt tail to a bat with dbl tail.
|
| batcalc.flt
| Coerce an dbl tail to a bat with flt tail.
|
| batcalc.ifthen
| Ifthen operation to assemble a conditional result
|
| batcalc.ifthenelse
| If-then-else operation to assemble a conditional result
|
| batcalc.int
| Coerce an str tail to a bat with int tail.
|
| batcalc.isnil
| Unary check for nil over the tail of the bat
|
| batcalc.lng
| Coerce an bit tail to a bat with lng tail.
|
| batcalc.not
| Return a BAT with the negated tail
|
| batcalc.oid
| Coerce an lng tail to a bat with oid tail.
|
| batcalc.or
| Binary BAT calculator function with new BAT result
|
| batcalc.sht
| Coerce an bit tail to a bat with sht tail.
|
batcalc.str
|
| batcalc.wrd
| Coerce an bit tail to a bat with wrd tail.
|
| batcalc.xor
| Binary BAT calculator function with new BAT result
|
|
| batcolor.blue
| Extracts blue component from a color atom
|
| batcolor.cb
| Extracts Cb(blue color) component from a color atom
|
| batcolor.color
| Converts string to color
|
| batcolor.cr
| Extracts Cr(red color) component from a color atom
|
| batcolor.green
| Extracts green component from a color atom
|
| batcolor.hsv
| Converts an HSV triplets to a color atom
|
| batcolor.hue
| Extracts hue component from a color atom
|
| batcolor.luminance
| Extracts Y(luminance) component from a color atom
|
| batcolor.red
| Extracts red component from a color atom
|
| batcolor.rgb
| Converts an RGB triplets to a color atom
|
| batcolor.saturation
| Extracts saturation component from a color atom
|
| batcolor.str
| Identity mapping for string bats
|
| batcolor.value
| Extracts value component from a color atom
|
|
batmmath.acos
|
batmmath.asin
|
batmmath.atan
|
batmmath.atan2
|
batmmath.ceil
|
batmmath.cos
|
batmmath.cosh
|
batmmath.exp
|
batmmath.fabs
|
batmmath.floor
|
batmmath.fmod
|
batmmath.log
|
batmmath.log10
|
batmmath.pow
|
batmmath.sin
|
batmmath.sinh
|
batmmath.sqrt
|
batmmath.tan
|
batmmath.tanh
|
|
batmtime.day
|
batmtime.hours
|
batmtime.milliseconds
|
batmtime.month
|
batmtime.seconds
|
batmtime.year
|
|
| batstr.chrAt
| String array lookup operation.
|
| batstr.endsWith
| Suffix check.
|
| batstr.length
| Return the length of a string.
|
batstr.like
|
| batstr.like_uselect
| Perform SQL like operation against a string bat
|
| batstr.ltrim
| Strip whitespaces from start of a string.
|
| batstr.nbytes
| Return the string length in bytes.
|
| batstr.r_search
| Reverse search for a substring. Returns position, -1 if not found.
|
| batstr.replace
| Insert a string into another
|
| batstr.rtrim
| Strip whitespaces from end of a string.
|
| batstr.search
| Search for a substring. Returns position, -1 if not found.
|
| batstr.startsWith
| Prefix check.
|
| batstr.string
| Return the tail s[offset..n] of a string s[0..n].
|
| batstr.substitute
| Substitute first occurrence of 'src' by
'dst'. Iff repeated = true this is
repeated while 'src' can be found in the
result string. In order to prevent
recursion and result strings of unlimited
size, repeating is only done iff src is
not a substring of dst.
|
| batstr.substring
| Substring extraction using [start,start+length]
|
| batstr.toLower
| Convert a string to lower case.
|
| batstr.toUpper
| Convert a string to upper case.
|
| batstr.trim
| Strip whitespaces around a string.
|
| batstr.unicodeAt
| get a unicode character (as an int) from a string position.
|
|
| bbp.bind
| Locate the BAT using its BBP index in the BAT buffer pool
|
| bbp.close
| Close the bbp box.
|
| bbp.commit
| Commit updates for this client.
|
| bbp.deposit
| Relate a logical name to a physical BAT in the buffer pool.
|
| bbp.destroy
| Schedule a BAT for removal at session end or immediately.
|
| bbp.discard
| Remove the BAT from the box.
|
| bbp.getCount
| Create a BAT with the cardinalities of all known BATs
|
| bbp.getDirty
| Create a BAT with the dirty/ diffs/clean status
|
| bbp.getDiskSpace
| Estimate the amount of disk space occupied by dbfarm
|
| bbp.getHeadType
| Map a BAT into its head type
|
| bbp.getHeat
| Create a BAT with the heat values
|
| bbp.getKind
| Create a BAT with the persistency status
|
| bbp.getLRefCount
| Utility for debugging MAL interpreter
|
| bbp.getLocation
| Create a BAT with their disk locations
|
| bbp.getName
| Map a BAT into its internal name
|
| bbp.getNames
| Map BAT into its bbp name
|
| bbp.getObjects
| View of the box content.
|
| bbp.getPageSize
| Obtain the memory page size
|
| bbp.getRNames
| Map a BAT into its bbp physical name
|
| bbp.getRefCount
| Utility for debugging MAL interpreter
|
| bbp.getStatus
| Create a BAT with the disk/load status
|
| bbp.getTailType
| Map a BAT into its tail type
|
| bbp.iterator
| Locate the next element in the box.
|
| bbp.open
| Locate the bbp box and open it.
|
| bbp.prelude
| Initialize the bbp box.
|
| bbp.release
| Remove the BAT from further consideration
|
| bbp.releaseAll
| Commit updates for this client.
|
| bbp.take
| Load a particular bat.
|
| bbp.toString
| Get the string representation of an element in the box.
|
|
| blob.blob
| Noop routine.
|
| blob.nitems
| get the number of bytes in this blob.
|
blob.prelude
|
| blob.toblob
| store a string as a blob.
|
| blob.tostring
| get the bytes from blob as a string,
starting at byte 'index' till the first
0 byte or the end of the blob.
|
|
| box.close
| Close the box.
|
| box.deposit
| Enter a new value into the box.
|
| box.destroy
| Destroy the box.
|
| box.discard
| Release the BAT from the client pool.
|
| box.getBoxNames
| Retrieve the names of all boxes.
|
| box.iterator
| Locates the next element in the box.
|
| box.open
| Locate the box and open it.
|
| box.release
| Release the BAT from the client pool.
|
| box.releaseAll
| Release all objects for this client.
|
| box.take
| Locate the typed value in the box.
|
| box.toString
| Get the string representation of
the i-th element in the box.
|
|
| bpm.adapt
| Re-organize segment s using the selection (val1,val2) stored in bat rs.
|
| bpm.addPartition
| Add a partition to a fragmented temporary table.
|
| bpm.close
| Save and close the BAT partition box.
|
bpm.count
|
| bpm.delete
| Delete elements from the BAT partitions.
|
| bpm.deposit
| Create a new partitioned BAT by name.
|
| bpm.derivePartition
| Create a derived fragmentation over the head using src.
|
| bpm.destroy
| Destroy the BAT partition box.
|
| bpm.discard
| Release all partitioned BATs.
|
| bpm.dump
| Give the details of the partition tree
|
| bpm.emptySet
| Implement the empty set constraints test efficiently.
|
bpm.epilogue
|
| bpm.fold
| Collapse the partitioned BAT into a single BAT.
|
| bpm.garbage
| Remove a temporary partitioned table.
|
| bpm.getDimension
| Obtain the partition boundary values.
|
| bpm.getNames
| Retrieve the names of all known partitioned BATs.
|
bpm.getNumberOfPartitions
|
| Return the number of partitions known
|
| bpm.hasMoreElements
| Localize the next partition for processing.
|
| bpm.hashPartition
| Create a hash partition on a BAT.
|
| bpm.hashPartitions
| Ensure all partitions have a hash in the head.
|
| bpm.insert
| Insert elements into the BAT partitions.
|
bpm.mapAlias
|
bpm.mapBid
|
bpm.mapName
|
bpm.mapNxt
|
bpm.mapPrv
|
bpm.mapThghDbl
|
bpm.mapThghLng
|
bpm.mapTlowDbl
|
bpm.mapTlowLng
|
| bpm.new
| Create a temporary partitioned table.
|
| bpm.newIterator
| Create an iterator over the BAT partitions.
|
| bpm.open
| Locate and open the BAT partition box.
|
| bpm.partition
| Split all partitions that cover the split value.
|
| bpm.pieces
| Count the number of partitions.
|
bpm.prelude
|
| bpm.rangePartition
| Create the partitions based on a range vector.
|
bpm.rangePartitionSort
|
| Create the partitions based on a range vector.
|
| bpm.replace
| Replace the content of the BAT partitions.
|
bpm.saveCatalog
|
| bpm.select
| Partitioned based selection
|
| bpm.sortPartitions
| Sort all partitions of alias b on the tail.
|
| bpm.sortTail
| Implement the sort on tail for partitioned BAT efficiently.
|
| bpm.splitquant
| Split all partitions to fit into a memory bound in KB
|
| bpm.take
| Retrieve a single component of a partitioned BAT by index.
|
| bpm.unfold
| Unfold a BAT into a partitioned one.
|
|
| bstream.create
| create a buffered stream
|
| bstream.destroy
| destroy bstream
|
| bstream.read
| read at least size bytes into the buffer of s
|
|
| calc.!=
| Inequality of two inets
|
calc.%
|
calc.*
|
| calc.+
| Concatenate two strings
|
| calc.-
| negative value
|
calc./
|
| calc.<
| Whether v is less than w
|
calc.<<
|
| calc.<=
| Whether v is less than or equal to w
|
| calc.=
| Equality of two inets
|
| calc.==
| Equality of two timestamps
|
| calc.>
| Whether v is greater than w
|
| calc.>=
| Whether v is equal to or greater than w
|
calc.>>
|
| calc.abs
| absolute value
|
calc.and
|
calc.bat
|
calc.between
|
| calc.bit
| coercion dbl to bit
|
calc.blob
|
| calc.bte
| coercion lng to bte
|
| calc.chr
| coercion lng to chr
|
calc.date
|
calc.daytime
|
| calc.dbl
| coercion lng to dbl
|
| calc.flt
| coercion lng to flt
|
| calc.getBAT
| Coerce bat to BAT identifier
|
calc.getBATidentifier
|
| Coerce bat to BAT identifier
|
calc.ifthenelse
|
| calc.inet
| Convert a string to an inet
|
| calc.int
| coercion dbl to int
|
| calc.inv
| inverse value (1/x)
|
| calc.isnil
| Nil test for inet value
|
| calc.isnotnil
| is a value not equal to nil?
|
calc.length
|
| calc.lng
| coercion dbl to lng
|
| calc.max
| Maximum test for timestamp value
|
| calc.max_no_nil
| Maximum test for timestamp value
|
| calc.min
| Minimum test for timestamp value
|
| calc.min_no_nil
| Minimum test for timestamp value
|
| calc.newoid
| Reserves a range of consecutive unique OIDs; returns the lowest
in range. equivalent to newoid(0,incr)
|
calc.not
|
| calc.oid
| coercion dbl to oid
|
calc.or
|
calc.ptr
|
| calc.setoid
| Equivalent to setoid(1:oid).
|
| calc.sht
| coercion dbl to sht
|
| calc.sign
| Returns +1, 0, -1 based on the sign of the given expression
|
calc.sizeof
|
calc.sqladd
|
calc.sqlblob
|
| calc.str
| coercion dbl to str
|
calc.timestamp
|
calc.void
|
| calc.wrd
| coercion dbl to wrd
|
calc.xor
|
|
| clients.addScenario
| add the given scenario to the allowed scenarios for the given user
|
| clients.addUser
| Allow user with password access to the given scenarios
|
clients.changePassword
|
| Change the password for the current user
|
clients.changeUsername
|
| Change the username of the user into the new string
|
clients.checkPermission
|
| Check permission for a user
|
| clients.exit
| Terminate the session for a single client using a soft error.
|
| clients.getActions
| Pseudo bat of client's command counts.
|
| clients.getId
| Return a number that uniquely represents the current client.
|
| clients.getInfo
| Pseudo bat with client attributes.
|
clients.getLastCommand
|
| Pseudo bat of client's last command time.
|
| clients.getLogins
| Pseudo bat of client login time.
|
| clients.getScenario
| Retrieve current scenario name.
|
| clients.getTime
| Pseudo bat of client's total time usage(in usec).
|
| clients.getUsername
| Return the username of the currently logged in user
|
| clients.getUsers
| return a BAT with user id and name available in the system with access to the given scenario(s)
|
| clients.quit
| Terminate the server.
This command can only be initiated from the console.
|
clients.removeScenario
|
| remove the given scenario from the allowed scenarios for the given user
|
| clients.removeUser
| Remove the given user from the system
|
| clients.setHistory
| Designate console history file for readline.
|
| clients.setListing
| Turn on/off echo of MAL instructions:
2 - show mal instruction,
4 - show details of type resolutoin,
8 - show binding information.
|
| clients.setPassword
| Set the password for the given user
|
| clients.setScenario
| Switch to other scenario handler, return previous one.
|
| clients.shutdown
| Close all client connections. If forced=false the
clients are moved into FINISHING mode, which means that
the process stops at the next cycle of the scenario.
If forced=true all client processes are immediately killed
|
| clients.stop
| Stop the query execution at the next eligble statement.
|
| clients.suspend
| Put a client process to sleep for some time.
It will simple sleep for a second at a time, until
the awake bit has been set in its descriptor
|
| clients.wakeup
| Wakeup a client process
|
|
| cluster.column
| Reorder tail of the BAT using the cluster map
|
| cluster.key
| Create the hash key list
|
| cluster.map
| Reorder tail of bat b, using a cluster map
|
| cluster.new
| Compute the cluster map for bat b of hash key values. A cluster map is a list of unique (new) BUN positions. The p(refix) sum is a by product which returns the prefix sum of the per masked key frequency.
|
| cluster.table
| Cluster the BATs using the first one as reference.
Return the oid map used
|
|
| color.blue
| Extracts blue component from a color atom
|
| color.cb
| Extracts Cb(blue color) component from a color atom
|
| color.color
| Converts string to color
|
| color.cr
| Extracts Cr(red color) component from a color atom
|
| color.green
| Extracts green component from a color atom
|
| color.hsv
| Converts an HSV triplets to a color atom
|
| color.hue
| Extracts hue component from a color atom
|
| color.luminance
| Extracts Y(luminance) component from a color atom
|
| color.red
| Extracts red component from a color atom
|
| color.rgb
| Converts an RGB triplets to a color atom
|
| color.saturation
| Extracts saturation component from a color atom
|
| color.str
| Converts color to string
|
| color.value
| Extracts value component from a color atom
|
| color.ycc
| Converts an YCC triplets to a color atom
|
|
| const.close
| Close the constant box.
|
| const.deposit
| Add a variable to the box.
|
| const.destroy
| Destroy the box.
|
| const.discard
| Release the const from the box.
|
| const.epiloque
| Cleanup the const box
|
const.hasMoreElements
|
| Locate next element in the box.
|
| const.newIterator
| Locate next element in the box.
|
| const.open
| Locate and open the constant box.
|
| const.prelude
| Initialize the const box
|
| const.release
| Release a constant value.
|
| const.releaseAll
| Release all variables in the box.
|
| const.take
| Take a variable out of the box.
|
| const.toString
| Get the string representation of an element in the box.
|
|
| constraints.emptySet
| Check if the BAT is empty.
|
|
| crackers.DeleteMap
| Throw away a certain map
|
crackers.InsertAVLIndex
|
| Insert u in the AVL tree index of BAT b
|
crackers.activeCacheConsciousCrackHashJoin
|
| Join two maps based on head values with active cracking. Align the maps to avoid overlapping pieces. Reuse hash tables
|
| crackers.alignJoin
| Join and on the fly align a map with an intermediate result bat, i.e., not cracked
|
| crackers.alignedJoin
| Join an aligned cracker bat with a map
|
| crackers.bandJoin
| Band Join two maps based on head values.
Continuously crack the right BAT for each tuple of the left one
|
crackers.buildAVLIndex
|
| Create an AVL tree index for this BAT
|
crackers.cacheConsciousCrackHashJoin
|
| Join two maps based on head values. Align the maps to avoid overlapping pieces. Reuse hash tables
|
crackers.cacheConsciousCrackHashJoinAlignOnly
|
| Join two maps based on head values. Align the maps to avoid overlapping pieces. Reuse hash tables
|
crackers.crackHashJoin
|
| Join two maps based on head values. Align the maps to avoid overlapping pieces. Reuse hash tables
|
| crackers.crackJoin
| Join two maps based on head values. Align the maps to avoid overlapping pieces
|
crackers.crackOrdered
|
| Break a BAT into three pieces with
tail<mid, tail==mid, tail>mid,
respectively; maintaining the head-oid order within each piece.
|
crackers.crackOrdered_validate
|
| Validate whether a BAT is correctly broken into five pieces with
tail<low, tail==low, low<tail<hgh, tail==hgh, tail>hgh,
respectively; maintaining the head-oid order within each piece.
|
crackers.crackUnordered_validate
|
| Validate whether a BAT is correctly broken into five pieces with
tail<low, tail==low, low<tail<hgh, tail==hgh, tail>hgh,
respectively.
|
| crackers.deleteAVL
| Delete a collection of values from the index
|
crackers.deletionsOnNeed
|
| Keep the deletions BAT separatelly and do a complete merge only
if a relevant query arrives in the future
|
crackers.deletionsOnNeedGradually
|
| Keep the deletions BAT separatelly and merge only what is
needed if a relevant query arrives in the future
|
crackers.deletionsOnNeedGraduallyRipple
|
| Keep the deletions BAT separatelly and merge only what is
needed using ripple if a relevant query arrives in the future
|
| crackers.djoinselect
| Use the pivot. For each tuple in pivot with a 0, check if the respective tuple (in the same position)
in the tail of cpair satisfies the range restriction. If yes mark the pivot BUN as 1.
|
| crackers.dproject
| Sync the cracking pair and project the tail. Use for disjunctive queries that require a larger bit vector
|
| crackers.dselect
| Crack based on dbl and evaluate the dbl disjunctive predicate outside the cracked area. Return a bit vector.
|
crackers.extendCrackerBAT
|
| Extend the cracker column by P positions
|
crackers.extendCrackerMap
|
| Extend the cracker map by P positions
|
crackers.fmaddReference
|
| add bp reference to map set of b
|
crackers.fmclearReferences
|
| clear all references
|
| crackers.fmcreateMap
| make new map for debugging
|
| crackers.fmremoveMap
| clear all debugging map
|
crackers.fullAlignment
|
| Align a bat with the cracks on a map
|
crackers.getCrackerBAT
|
| Get the cracker BAT of b
|
| crackers.getMap
| Get a certain map
|
crackers.getTotalStorage
|
| Get the number of total tuples stored in sideways maps
|
| crackers.hselect
| Retrieve the subset head using a cracker
index producing preferably a BATview.
|
| crackers.insert
| Keep the insertions BAT separatelly and merge in the future on demand with the Ripple
|
crackers.insertionsBForce
|
| Merge the insertions BAT with the cracker bat and update the cracker index
|
crackers.insertionsBOnNeed
|
| Keep the insertions BAT separatelly and do a complete merge
only if a relevant query arrives in the future
|
crackers.insertionsBOnNeedGradually
|
| Keep the insertions BAT separatelly and merge only what is
needed if a relevant query arrives in the future
|
crackers.insertionsBOnNeedGraduallyRipple
|
| Keep the insertions BAT separatelly and merge only what is needed
using the ripple strategy if a relevant query arrives in the future
|
crackers.insertionsForget
|
| Append c to the cracked BAT of b and completelly forget the cracker index
|
crackers.insertionsPartiallyForget
|
| Append c to the cracked BAT of b and partially forget
the cracker index, i.e., forget only what is affected
|
| crackers.joinselect
| Use the pivot. For each tuple in pivot with a 1, check if the respective tuple (in the same position)
in the tail of cpair satisfies the range restriction. If not mark the pivot BUN as 0.
|
| crackers.joinuselect
| Join left and right on head-OIDs.
From right, only those BUNs qualify that satisfy the range-restriction on the tail.
If inPlace is TRUE (and left has an OID head and is not a BAT-view), we operate in-place,
overwriting left and returning it as result. Otherwise, the result is a new [:oid,:void] BAT.
If isForeignKey is TRUE, we assume that each tuple from left finds a match in right,
and hence skip the respective check.
(NOTE: This may lead to CRASHES, if isForeignKey is incorrectly passed as TRUE!)
|
| crackers.mapCount
| Retrieve the size of the map
|
crackers.markedproject
|
| Sync the cracking pair and project the tail. The result bat has a marked head
|
crackers.materializeHead
|
| Materialize the head of BAT b
|
crackers.pmaddReference
|
| add bp reference to map set of b
|
crackers.pmclearReferences
|
| clear all references to b
|
crackers.pmjoinselect
|
| Use the pivot. For each tuple in pivot with a 1, check if the respective tuple (in the same position)
in the tail of cpair(collection of pieces) satisfies the range restriction. If not mark the pivot BUN as 0.
|
| crackers.pmmaxTail
| Sync/crack the map and get the max of the tail
|
| crackers.pmproject
| Sync the map and project the tail based on the pivot
|
| crackers.pmselect
| Crack based on dbl and evaluate the dbl conjunctive predicate. Return a bit vector.
|
| crackers.pmtselect
| Crack based on dbl and project the dbl tail .
|
crackers.positionproject
|
| Sync the cracking pair and project the tail. The pivot holds the positions to be projected
|
crackers.printAVLTree_int
|
| Print the AVL Tree of the cracker index (for debugging purposes)
|
crackers.printCrackerBAT
|
| Print the cracker BAT of b
|
crackers.printCrackerDeletions
|
| Print the pending deletions of the cracker BAT of b
|
crackers.printCrackerIndexBATpart
|
| Print the cracker index of b
|
crackers.printCrackerInsertions
|
| Print the pending insertions of the cracker BAT of b
|
crackers.printPendingInsertions
|
| Print the pending insertions
|
| crackers.project
| Sync the cracking pair and project the tail
|
| crackers.projectH
| Sync the cracking pair and project the head
|
| crackers.select
| Retrieve the subset using a cracker
index producing preferably a BATview.
|
| crackers.select2
| Similar to select but always make sure that we do not create a large piece
i.e., bigger than half the size of the cracked piece
|
| crackers.selectAVL
| Retrieve the subset using the AVL index
|
crackers.setStorageThreshold
|
| set the maximum number of total tuples that can be stored in sideways maps
|
| crackers.simpleJoin
| Join two maps based on head values by exploiting the already existing partitioning information
|
crackers.singlePassJoin
|
| First partition on separate pieces the left input based on the right index. Then join matching pieces
|
crackers.sizeCrackerDeletions
|
| Get the size of the pending deletions of the cracker BAT of b
|
crackers.sizeCrackerInsertions
|
| Get the size of the pending insertions of the cracker BAT of b
|
crackers.sizePendingInsertions
|
| Get the size of the pending insertions for this map
|
crackers.sortBandJoin
|
| Band Join two maps based on head values.
First sort the right BAT and then continuously binary search the right BAT for each tuple of the left one
|
| crackers.tselect
| Retrieve the subset tail using a cracker
index producing preferably a BATview.
|
| crackers.uselect
| Retrieve the subset using a cracker
index producing preferably a BATview.
|
crackers.verifyCrackerIndex
|
| Check the cracker index and column, whether each value is in the correct chunk
|
crackers.zcrackOrdered
|
| Break a BAT into three pieces with
tail<=low, low<tail<=hgh, tail>hgh,
respectively; maintaining the head-oid order within each piece.
|
crackers.zcrackOrdered_validate
|
| Validate whether a BAT is correctly broken into three pieces with
tail<=low, low<tail<=hgh, tail>hgh,
respectively; maintaining the head-oid order within each piece.
|
crackers.zcrackUnordered
|
| Break a BAT into three pieces with
tail<=low, low<tail<=hgh, tail>hgh,
respectively.
|
crackers.zcrackUnordered_validate
|
| Validate whether a BAT is correctly broken into three pieces with
tail<=low, low<tail<=hgh, tail>hgh,
respectively.
|
|
| date.!=
| Equality of two dates
|
| date.<
| Equality of two dates
|
| date.<=
| Equality of two dates
|
| date.==
| Equality of two dates
|
| date.>
| Equality of two dates
|
| date.>=
| Equality of two dates
|
| date.date
| Noop routine.
|
| date.isnil
| Nil test for date value
|
|
| daytime.!=
| Equality of two daytimes
|
| daytime.<
| Equality of two daytimes
|
| daytime.<=
| Equality of two daytimes
|
| daytime.==
| Equality of two daytimes
|
| daytime.>
| Equality of two daytimes
|
| daytime.>=
| Equality of two daytimes
|
| daytime.isnil
| Nil test for daytime value
|
|
| factories.getArrival
| Retrieve the time stamp the last call was made.
|
| factories.getCaller
| Retrieve the unique identity of the factory caller.
|
factories.getDeparture
|
| Retrieve the time stamp the last answer was returned.
|
| factories.getOwners
| Retrieve the factory owners table.
|
| factories.getPlants
| Retrieve the names for all active factories.
|
| factories.shutdown
| Close a factory.
|
|
| group.avg
| grouped tail average
|
| group.count
| Grouped count
|
| group.derive
| Cross tabulation group extension step. Returned head values are
identical as in 'ct'. Tail values are from the same domain and
indicate further refinement of the groups in 'ct', taking into
account also the tail-values in 'attr'.
|
| group.max
| Select the minimum element of each group
|
| group.min
| Select the minimum element of each group
|
| group.new
| Cross tabulation group initialization like GRPgroup, but with
user provided #bits in hashmask and #distinct values in range.
|
group.prelude
|
| group.refine
| refine the ordering of a tail-ordered BAT by sub-ordering on the
values of a second bat 'a' (where the heads of a and b match 1-1).
The effect of this is similar to (hash-based) GRPderive, with the
distinction that the group ids respect the ordering of the group
values.
|
| group.refine_reverse
| refine the ordering of a tail-ordered BAT by sub-ordering on the
values of a second bat 'a' (where the heads of a and b match 1-1).
The effect of this is similar to (hash-based) GRPderive, with the
distinction that the group ids respect the ordering of the group
values.
|
| group.size
| Grouped count of true values
|
| group.sum
| Tail sum of groups of a sliding window of fixed size
|
| group.variance
| grouped tail variance
|
|
identifier.identifier
|
| Cast a string to an identifer
|
| identifier.prelude
| Initialize the module
|
|
| inet.!=
| Inequality of two inets
|
| inet.<
| Whether v is less than w
|
| inet.<<
| Whether v is contained within w
|
| inet.<<=
| Whether v is contained within or is equal to w
|
| inet.<=
| Whether v is less than or equal to w
|
| inet.=
| Equality of two inets
|
| inet.>
| Whether v is greater than w
|
| inet.>=
| Whether v is equal to or greater than w
|
| inet.>>
| Whether v contains w
|
| inet.>>=
| Whether v contains or is equal to w
|
| inet.abbrev
| Abbreviated display format as text
|
| inet.broadcast
| Returns the broadcast address for network
|
| inet.host
| Extract IP address as text
|
| inet.hostmask
| Construct host mask for network
|
| inet.isnil
| Nil test for inet value
|
| inet.masklen
| Extract netmask length
|
| inet.netmask
| Construct netmask for network
|
| inet.network
| Extract network part of address
|
| inet.new
| Create an inet from a string literal
|
| inet.setmasklen
| Set netmask length for inet value
|
| inet.text
| Extract IP address and netmask length as text
|
|
| inspect.equalType
| Return true if both operands are of the same type
|
| inspect.getAddress
| Returns the function signature(s).
|
| inspect.getAddresses
| Obtain the function address.
|
| inspect.getAtomNames
| Collect a BAT with the atom names.
|
| inspect.getAtomSizes
| Collect a BAT with the atom sizes.
|
| inspect.getAtomSuper
| Collect a BAT with the atom names.
|
| inspect.getComment
| Returns the function help information.
|
inspect.getDefinition
|
| Returns a string representation of a specific function.
|
inspect.getEnvironment
|
| Collect the environment variables.
|
| inspect.getFunction
| Obtain the function name.
|
| inspect.getKind
| Obtain the instruction kind.
|
| inspect.getModule
| Obtain the function name.
|
| inspect.getSignature
| Returns the function signature(s).
|
inspect.getSignatures
|
| Obtain the function signatures.
|
| inspect.getSize
| Return the storage size for a function (in bytes).
|
| inspect.getSource
| Return the original input for a function.
|
inspect.getStatistics
|
| Get optimizer property statistics
such as #calls, #total actions, #total time
|
| inspect.getType
| Return the concrete type of a variable (expression).
|
| inspect.getTypeIndex
| Return the type index of a variable. For BATs, return
the type index for its tail.
|
| inspect.getTypeName
| Get the type name associated with a type id.
|
| inspect.getWelcome
| Return the server message of the day string
|
|
| io.data
| Signals receipt of tuples in a file fname.
It returns the name of the file, if it still exists.
|
| io.export
| Export a BAT as ASCII to a file. If the 'filepath' is not absolute, it
is put into the .../dbfarm/$DB directory. Success of failure is indicated.
|
| io.ftable
| Print an n-ary table to a file.
|
| io.import
| 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.
|
| io.print
| Print a MAL value tuple .
|
| io.printf
| Select default format
|
| io.prompt
| Print a MAL value without brackets.
|
| io.stderr
| return the error stream for the database console
|
| io.stdin
| return the input stream to the database client
|
| io.stdout
| return the output stream for the database client
|
| io.table
| Print an n-ary table.
|
|
| language.assert
| Assertion test.
|
| language.assertSpace
| Ensures that the current call does not consume
more than depth*vtop elements on the stack.
|
| language.call
| Evaluate a program stored in a BAT.
|
| language.dataflow
| The current guarded block is executed using dataflow control.
|
| language.newRange
| This routine introduces an iterator
over a scalar domain.
|
| language.nextElement
| Advances the iterator with a fixed value
until it becomes >= last.
|
| language.raise
| Raise an exception labeled
with a specific message.
|
| language.register
| Compile the code string and register it as a MAL function.
|
| language.setIOTrace
| Set the flag to trace the IO
|
language.setMemoryTrace
|
| Set the flag to trace the memory footprint
|
language.setThreadTrace
|
| Set the flag to trace the interpreter threads
|
language.setTimerTrace
|
| Set the flag to trace the execution time
|
| language.source
| Merge the instructions stored in the
file with the current program.
|
|
| lock.create
| Create an unset lock
|
| lock.destroy
| Destroy a lock
|
| lock.set
| Try to set a lock. If set, block till it is freed
|
| lock.tostr
| Overloaded atom function
|
| lock.try
| Try a lock. If free set it, if not return EBUSY
|
| lock.unset
| Unset a lock
|
|
mal.multiplex
|
|
| manual.completion
| Produces the wordcompletion table.
|
| manual.createXML
| Produces a XML-formatted manual over all modules loaded.
|
| manual.help
| Produces a list of all <module>.<function> that match
the text pattern. The wildcard '*' can be used for <module>
and <function>. Using the '(' asks for signature information and
using ')' asks for the complete help record.
|
| manual.index
| Produces an overview of all names grouped by module.
|
| manual.search
| Search the manual for command descriptions that match the
regular expression 'text'
|
| manual.section
| Generate a synopsis of a module for the reference manual
|
| manual.summary
| Produces a manual with help lines grouped by module.
|
|
| mapi.bind
| Bind a remote variable to a local one.
|
| mapi.connect
| Establish connection with a remote mserver.
|
| mapi.connect_ssl
| Establish connection with a remote mserver using the
secure socket layer.
|
| mapi.destroy
| Destroy the handle for an Mserver.
|
| mapi.disconnect
| Terminate the session.
|
| mapi.error
| Check for an error in the communication.
|
| mapi.explain
| Turn the error seen into a string.
|
| mapi.fetch_all_rows
| Retrieve all rows into the cache.
|
| mapi.fetch_field
| Retrieve a single chr field.
|
mapi.fetch_field_array
|
| Retrieve all fields for a row.
|
| mapi.fetch_line
| Retrieve a complete line.
|
| mapi.fetch_reset
| Reset the cache read line.
|
| mapi.fetch_row
| Retrieve the next row for analysis.
|
| mapi.finish
| Remove all remaining answers.
|
| mapi.getError
| Get error message.
|
| mapi.get_field_count
| Return number of fields.
|
| mapi.get_row_count
| Return number of rows.
|
| mapi.listen
| Start the Mapi listener on <port> for <maxusers>.
For a new client connection MAL procedure <cmd>(Stream s_in, Stream s_out)
is called.If no <cmd> is specified a new client thread is forked.
|
| mapi.listen_ssl
| Start the Mapi listener on <port> for <maxusers> using SSL.
<keyfile> and <certfile> give the path names for files with the
server key and certificates in PEM format. For a new client connection
MAL procedure <cmd>(Stream s_in, Stream s_out) is called.
If no <cmd> is specified a new client thread is forked.
|
| mapi.lookup
| Retrieve the connection identifier.
|
| mapi.malclient
| Start a Mapi client for a particular stream pair.
|
| mapi.next_result
| Go to next result set.
|
| mapi.ping
| Test availability of an Mserver.
|
| mapi.prepare
| Prepare a query for execution.
|
| mapi.put
| Prepare sending a value to a remote site.
|
| mapi.query
| Sent the query for execution
|
| mapi.query_array
| Sent the query for execution replacing '?' by arguments.
|
| mapi.query_handle
| Sent the query for execution.
|
| mapi.reconnect
| Re-establish a connection.
|
| mapi.resume
| Resume connection listeners.
|
| mapi.rpc
| Sent a simple query for execution.
|
| mapi.setAlias
| Give the channel a logical name.
|
| mapi.stop
| Terminate connection listeners.
|
| mapi.suspend
| Suspend accepting connections.
|
| mapi.trace
| Toggle the Mapi library debug tracer.
|
|
| mat.hasMoreElements
| Find the next element in the merge table
|
| mat.info
| retrieve the definition from the partition catalogue
|
| mat.new
| Define a Merge Association Table (MAT)
|
| mat.newIterator
| Create an iterator over a MAT
|
| mat.pack
| Materialize the MAT into the first BAT
|
mat.print
|
|
| mdb.List
| Dump the routine M.F on standard out.
|
| mdb.collect
| Dump the previous instruction to a temporary file
|
| mdb.dot
| Dump the data flow of the function
M.F in a format recognizable by the
command 'dot' on the file s
|
| mdb.dump
| Dump instruction, stacktrace, and stack
|
| mdb.getContext
| Extract the context string from the exception message
|
| mdb.getDebug
| Get the kernel debugging bit-set.
See the MonetDB configuration file for details
|
| mdb.getDefinition
| Returns a string representation of the current function
with typing information attached
|
| mdb.getException
| Extract the variable name from the exception message
|
| mdb.getReason
| Extract the reason from the exception message
|
| mdb.getStackDepth
| Return the depth of the calling stack.
|
| mdb.getStackFrame
| Collect variable binding of current (n-th) stack frame.
|
mdb.getStackTrace
|
| mdb.grab
| Stop and debug another client process.
|
| mdb.inspect
| Run the debugger on a specific function
|
| mdb.lifespan
| Dump the current routine lifespan information on standard out.
|
| mdb.list
| Dump the routine M.F on standard out.
|
| mdb.listMapi
| Dump the current routine on standard out with Mapi prefix.
|
| mdb.modules
| List available modules
|
| mdb.setCatch
| Turn on/off catching exceptions
|
| mdb.setCount
| Turn on/off bat count statistics tracing
|
| mdb.setDebug
| Set the kernel debugging bit-set and return its previous value.
|
| mdb.setFlow
| Turn on/off memory flow debugger
|
| mdb.setIO
| Turn on/off io statistics tracing
|
| mdb.setMemory
| Turn on/off memory statistics tracing.
|
| mdb.setMemoryTrace
| Turn on/off memory foot print tracer for debugger
|
| mdb.setThread
| Turn on/off thread identity for debugger
|
| mdb.setTimer
| Turn on/off performance timer for debugger
|
| mdb.setTrace
| Turn on/off tracing of a variable
|
| mdb.start
| Start interactive debugger on a running factory
|
| mdb.stop
| Stop the interactive debugger
|
| mdb.var
| Dump the symboltable of routine M.F on standard out.
|
|
mkey.bulk_rotate_xor_hash
|
| pre: h and b should be synced on head
post: [:xor=]([:rotate=](h, nbits), [hash](b))
|
| mkey.hash
| compute a hash int number from any value
|
| mkey.rotate
| left-rotate an int by nbits
|
|
| mmath.acos
| The acos(x) function calculates the arc cosine of x, that is the
value whose cosine is x. The value is returned in radians and is
mathematically defined to be between 0 and PI (inclusive).
|
| mmath.asin
| The asin(x) function calculates the arc sine of x, that is the value
whose sine is x. The value is returned in radians and is mathematically
defined to be between -PI/20 and -PI/2 (inclusive).
|
| mmath.atan
| The atan(x) function calculates the arc tangent of x, that is the value
whose tangent is x. The value is returned in radians and is mathematically
defined to be between -PI/2 and PI/2 (inclusive).
|
| mmath.atan2
| The atan2(x,y) function calculates the arc tangent of the two
variables x and y. It is similar to calculating the arc
tangent of y / x, except that the signs of both arguments are
used to determine the quadrant of the result. The value is
returned in radians and is mathematically defined to be between
-PI/2 and PI/2 (inclusive).
|
| mmath.ceil
| The ceil(x) function rounds x upwards to the nearest integer.
|
| mmath.cos
| The cos(x) function returns the cosine of x, where x is given in
radians. The return value is between -1 and 1.
|
| mmath.cosh
| The cosh() function returns the hyperbolic cosine of x, which is
defined mathematically as (exp(x) + exp(-x)) / 2.
|
| mmath.cot
| The cot(x) function returns the Cotangent of x,
where x is given in radians
|
| mmath.exp
| The exp(x) function returns the value of e (the base of
natural logarithms) raised to the power of x.
|
| mmath.fabs
| The fabs(x) function returns the absolute value of the
floating-point number x.
|
| mmath.finite
| The finite(x) function returns true if x is neither infinite
nor a 'not-a-number' (NaN) value, and false otherwise.
|
| mmath.floor
| The floor(x) function rounds x downwards to the nearest integer.
|
| mmath.fmod
| The fmod(x,y) function computes the remainder of dividing x by y.
The return value is x - n * y, where n is the quotient of x / y,
rounded towards zero to an integer.
|
| mmath.isinf
| The isinf(x) function returns -1 if x represents negative
infinity, 1 if x represents positive infinity, and 0 otherwise.
|
| mmath.isnan
| The isnan(x) function returns true if x is 'not-a-number'
(NaN), and false otherwise.
|
| mmath.log
| The log(x) function returns the natural logarithm of x.
|
| mmath.log10
| The log10(x) function returns the base-10 logarithm of x.
|
| mmath.pi
| return an important mathematical value
|
| mmath.pow
| The pow(x,y) function returns the value of x raised to the power of y.
|
| mmath.rand
| return a random number
|
| mmath.round
| The round(n, m) returns n rounded to m places to the right
of the decimal point; if m is omitted, to 0 places. m can be
negative to round off digits left of the decimal point.
m must be an integer.
|
| mmath.sin
| The sin(x) function returns the cosine of x, where x is given in
radians. The return value is between -1 and 1.
|
| mmath.sinh
| The sinh() function returns the hyperbolic sine of x, which
is defined mathematically as (exp(x) - exp(-x)) / 2.
|
| mmath.sqrt
| The sqrt(x) function returns the non-negative square root of x.
|
| mmath.srand
| initialize the rand() function with a seed
|
| mmath.tan
| The tan(x) function returns the tangent of x,
where x is given in radians
|
| mmath.tanh
| The tanh() function returns the hyperbolic tangent of x, which is
defined mathematically as sinh(x) / cosh(x).
|
|
| mtime.add
| returns the timestamp that comes 'msecs'
(possibly negative) after 'value'.
|
| mtime.adddays
| returns the date after a number
of days (possibly negative).
|
| mtime.addmonths
| returns the date after a number of
months (possibly negative).
|
| mtime.addyears
| returns the date after a number
of years (possibly negative).
|
| mtime.compute
| compute the date from a rule in a given year
|
mtime.current_date
|
mtime.current_time
|
mtime.current_timestamp
|
| mtime.date
| extracts date from timestamp in a
specific timezone.
|
mtime.date_add_month_interval
|
| Add months to a date
|
mtime.date_add_sec_interval
|
| Add seconds to a date
|
mtime.date_sub_sec_interval
|
| Subtract seconds from a date
|
| mtime.date_to_str
| create a string from the date, using the specified format (see man strftime)
|
| mtime.day
| extract day from rule.
|
| mtime.dayname
| Returns day name from a number
between [1-7], str(nil) otherwise.
|
| mtime.daynum
| Returns number of day [1-7] from a
string or nil if does not match any.
|
| mtime.dayofweek
| Returns the current day of the week
where 1=sunday, .., 7=saturday
|
| mtime.dayofyear
| Returns N where d is the Nth day
of the year (january 1 returns 1)
|
| mtime.daytime
| default time with zeroed components
|
| mtime.diff
| returns the number of milliseconds
between 'val1' and 'val2'.
|
| mtime.dst
| return whether DST holds in the
timezone at a certain point of time.
|
| mtime.end_dst
| extract rule that determines
end of DST from timezone.
|
mtime.epilogue
|
| mtime.hours
| extracts hour from daytime
|
| mtime.local_timezone
| get the local timezone in seconds
|
| mtime.milliseconds
| extracts milliseconds from daytime
|
| mtime.minutes
| extract minutes from rule.
|
| mtime.month
| extract month from rule.
|
| mtime.monthname
| Returns month name from a number
between [1-12], str(nil) otherwise.
|
| mtime.monthnum
| Returns month number [1-12] from a string
or nil if does not match any.
|
| mtime.msec
| get time of day in msec since 1-1-1970.
|
| mtime.msecs
| convert date components to milliseconds
|
| mtime.olddate
| create a date from the old instant
format.
|
| mtime.oldduration
| parse the old duration format and
return an (estimated) number of days.
|
mtime.prelude
|
| mtime.rule
| create a DST start/end date rule.
|
| mtime.seconds
| extracts seconds from daytime
|
| mtime.setTimezone
| Test and set the timezone.
|
| mtime.start_dst
| extract rule that determines
start of DST from timezone.
|
| mtime.str_to_date
| create a date from the string, using the specified format (see man strptime)
|
mtime.time_add_sec_interval
|
| Add seconds to a time
|
mtime.time_sub_sec_interval
|
| Subtract seconds from a time
|
| mtime.time_synonyms
| Allow synonyms for the parse format of
date/timestamp.
|
| mtime.timestamp
| creates a timestamp from (d,00:00:00) parameters (in the local timezone).
|
mtime.timestamp_add_month_interval
|
| Add months to a timestamp
|
mtime.timestamp_add_sec_interval
|
mtime.timestamp_sub_month_interval
|
| Subtract months from a timestamp
|
mtime.timestamp_sub_sec_interval
|
| mtime.timezone
| create a timezone as an hour difference
from GMT and a DST.
|
| mtime.timezone_local
| get the local timezone; which is used for printing timestamps
|
| mtime.weekday
| extract weekday from rule.
|
| mtime.weekofyear
| Returns the week number in the year.
|
| mtime.year
| extracts year from date (nonzero
value between -5867411 and +5867411).
|
|
|
| optimizer.accessmode
| Reduce the number of mode changes.
|
optimizer.accumulators
|
| Replace calculations with accumulator model
|
| optimizer.aliases
| Alias removal optimizer
|
optimizer.clrDebug
|
| optimizer.coercions
| Handle simple type coercions
|
optimizer.commonTerms
|
| Common sub-expression optimizer
|
| optimizer.constants
| Duplicate constant removal optimizer
|
| optimizer.costModel
| Estimate the cost of a relational expression
|
| optimizer.crack
| Replace algebra select with crackers select
|
| optimizer.dataflow
| Dataflow bracket code injection
|
| optimizer.deadcode
| Dead code optimizer
|
| optimizer.dumpQEP
| Produce an indented tree visualisation
|
| optimizer.emptySet
| Symbolic evaluation of empty BAT expressions
|
| optimizer.evaluate
| Evaluate constant expressions once.
|
| optimizer.factorize
| Turn function into a factory
|
optimizer.garbageCollector
|
| Garbage collector optimizer
|
| optimizer.heuristics
| Handle simple replacements
|
| optimizer.history
| Collect SQL query statistics
|
| optimizer.inline
| Expand inline functions
|
| optimizer.joinPath
| Join path constructor
|
| optimizer.joinselect
| Replace select with join select
|
| optimizer.macro
| Inline a target function used in a specific function.
|
| optimizer.mergetable
| Resolve the multi-table definitions
|
| optimizer.mitosis
| Modify the plan to exploit parallel processing on multiple cores
|
| optimizer.multiplex
| Compiler for multiplexed instructions.
|
| optimizer.octopus
| Map-execute-reduce parallelism optimizer
|
| optimizer.optimize
| Optimize a specific operation
|
| optimizer.orcam
| Inverse macro, find pattern and replace with a function call.
|
| optimizer.partitions
| Experiment with partitioned databases
|
| optimizer.peephole
| Perform local rewrites
|
| optimizer.prelude
| Initialize the optimizer
|
| optimizer.pushranges
| Push constant range selections through the program
|
| optimizer.recycle
| Replicator code injection
|
| optimizer.reduce
| Reduce the stack space claims
|
| optimizer.remap
| Remapping function calls to a their multiplex variant
|
optimizer.remoteQueries
|
| Resolve the multi-table definitions
|
| optimizer.replicator
| Replication optimizer
|
optimizer.setDebug
|
optimizer.showFlowGraph
|
| Dump the data flow of the function
M.F in a format recognizable by the
command 'dot' on the file s
|
| optimizer.showPlan
| Illustrate the plan derived so far
|
| optimizer.singleton
| Perform singleton optimization
|
optimizer.strengthReduction
|
| Move constant expressions out of the loop
|
| optimizer.trace
| Collect trace of a specific operation
|
|
| pcre.compile
| compile a pattern
|
| pcre.index
| match a pattern, return matched position (or 0 when not found)
|
pcre.like_uselect
|
| pcre.match
| POSIX pattern matching against a string
|
| pcre.patindex
| Location of the first POSIX pattern matching against a string
|
| pcre.pcre_quote
| Return a PCRE pattern string that matches the argument exactly.
|
| pcre.prelude
| Initialize pcre
|
| pcre.replace
| Replace _all_ matches of "pattern" in "origin_str" with "replacement".
Parameter "flags" accept these flags: 'i', 'm', 's', and 'x'.
'e': if present, an empty string is considered to be a valid match
'i': if present, the match operates in case-insensitive mode.
Otherwise, in case-sensitive mode.
'm': if present, the match operates in multi-line mode.
's': if present, the match operates in "dot-all"
The specifications of the flags can be found in "man pcreapi"
The flag letters may be repeated.
No other letters than 'e', 'i', 'm', 's' and 'x' are allowed in "flags".
Returns the replaced string, or if no matches found, the original string.
|
| pcre.select
| Select tuples based on the pattern
|
| pcre.sql2pcre
| Convert a SQL like pattern with the given escape character into a PCRE pattern.
|
| pcre.uselect
| Select tuples based on the pattern, only returning the head
|
|
| pqueue.dequeue_max
| Removes top element of the max-pqueue and updates it
|
| pqueue.dequeue_min
| Removes top element of the min-pqueue and updates it
|
| pqueue.enqueue_max
| Inserts element (oid,dbl) in the max-pqueue
|
| pqueue.enqueue_min
| Inserts element (oid,dbl) in the min-pqueue
|
| pqueue.init
| Creates an empty pqueue of bat a's tailtype with maximum size maxsize
|
| pqueue.topn_max
| Return the topn elements of the bat t using a max-pqueue
|
| pqueue.topn_min
| Return the topn elements of the bat t using a min-pqueue
|
pqueue.topreplace_max
|
| Replaces top element with input and updates max-pqueue
|
pqueue.topreplace_min
|
| Replaces top element with input and updates min-pqueue
|
|
| profiler.activate
| Make the specified counter active.
|
| profiler.cleanup
| Remove the temporary tables for profiling
|
| profiler.closeStream
| Stop sending the event records
|
| profiler.clrFilter
| Stop tracing the variable
|
| profiler.deactivate
| Deactivate the counter
|
| profiler.dumpTrace
| List the events collected
|
profiler.getDiskReads
|
| Obtain the number of physical reads
|
profiler.getDiskWrites
|
| Obtain the number of physical reads
|
| profiler.getEvent
| Retrieve the performance indicators of the previous instruction
|
profiler.getFootprint
|
| Get the memory footprint and reset it
|
| profiler.getMemory
| Get the amount of memory claimed and reset it
|
profiler.getSystemTime
|
| Obtain the user timing information.
|
| profiler.getTrace
| Get the trace details of a specific event
|
| profiler.getUserTime
| Obtain the user timing information.
|
| profiler.noop
| Fetch any pending performance events
|
| profiler.openStream
| Send the log events to a stream
|
| profiler.reset
| Clear the profiler traces
|
| profiler.setAll
| Short cut for setFilter(*,*).
|
| profiler.setEndPoint
| End performance tracing after mod.fcn
|
| profiler.setFilter
| Generate an event record for
every instruction where v is used.
|
| profiler.setNone
| Short cut for clrFilter(*,*).
|
profiler.setStartPoint
|
| Start performance tracing at mod.fcn
|
| profiler.start
| Start performance tracing
|
| profiler.stop
| Stop performance tracing
|
|
| recycle.dump
| Dump summary of recycle table into a file
|
| recycle.dumpQPat
| Dump statistics of query patterns
|
| recycle.epilogue
| Called at the start of a recycle controlled function
|
recycle.getCachePolicy
|
recycle.getRetainPolicy
|
recycle.getReusePolicy
|
| recycle.log
| Set the name of recycle log file
|
| recycle.monitor
| start/stop the monitoring (printing) of the recycler info (storage size used and number of statements retained)
|
| recycle.prelude
| Called at the start of a recycle controlled function
|
| recycle.reset
| Reset off all recycled variables
|
recycle.setCachePolicy
|
| Set recycler cache policy with alpha parameter
|
recycle.setRetainPolicy
|
| Set recycler retainment policy:
0- RETAIN_NONE: baseline, keeps stat, no retain, no reuse
1- RETAIN_ALL: infinite case, retain all
2- RETAIN_CAT: time-based semantics, retain if beneficial
3- RETAIN_ADAPT: adaptive temporal
|
recycle.setReusePolicy
|
| Set recycler reuse policy
|
| recycle.shutdown
| Clear the recycle cache
|
| recycle.start
| Initialize recycler for the current block
|
| recycle.stop
| Cleans recycler bookkeeping
|
|
| remote.connect
| Returns a newly created connection for dbname, user name and password.
|
| remote.create
| Create a user-defined connection to a server.
|
| remote.destroy
| Destroy a previously user-defined connection to a server.
|
| remote.disconnect
| Disconnects the connection for dbname.
|
| remote.epilogue
| Release the resources held by the remote module.
|
| remote.exec
| Remotely executes <mod>.<func> using the argument list of remote objects and returns the handle to its result
|
| remote.get
| Retrieves a copy of remote object ident.
|
| remote.getList
| List available databases with their property for use with connect().
|
| remote.prelude
| Initialise the remote module.
|
| remote.put
| Copies object to the remote site and returns its identifier.
|
| remote.register
| Register <mod>.<fcn> at the remote site.
|
|
| replicator.bind
| Create a named persistent BAT if it was not known
|
| replicator.bind_dbat
| Create a named persistent BAT if it was not known
|
| replicator.setMaster
| Mark the source of this database
|
replicator.setVersion
|
| Keep the latest version in the symbol table as a constant
|
|
| sabaoth.epilogue
| Release the resources held by the sabaoth module
|
sabaoth.getLocalConnectionHost
|
| Returns the hostname this server can be connected to, or nil if none
|
sabaoth.getLocalConnectionPort
|
| Returns the port this server can be connected to, or 0 if none
|
sabaoth.marchConnection
|
| Publishes the given host/port as available for connecting to this server
|
sabaoth.marchScenario
|
| Publishes the given language as available for this server
|
| sabaoth.prelude
| Initialise the sabaoth module
|
sabaoth.retreatScenario
|
| Unpublishes the given language as available for this server
|
| sabaoth.wildRetreat
| Unpublishes everything known for this server
|
|
| scheduler.choice
| Select the next step in a query memo plan
|
scheduler.costPrediction
|
| A sample cost prediction function
|
| scheduler.drop
| Remove a worker from the list
|
| scheduler.isolation
| Run a private copy of the MAL program
|
| scheduler.octopus
| Run the program block in parallel, but don't wait longer then t seconds
|
| scheduler.pick
| Pick up the first result
|
| scheduler.volumeCost
| A sample cost function based on materialized results
|
| scheduler.worker
| Add a worker site to the known list
|
|
| sema.create
| Create an unset sema, with an initial value
|
| sema.destroy
| Destroy a semaphore
|
| sema.down
| Decrement the semaphpore if >0; else block
|
| sema.up
| Increment the semaphore
|
|
| sql.forgetPrevious
| invalidate the previous instruction from future execution
|
sql.keepquery
|
sql.queryId
|
|
| sqlblob.sqlblob
| Noop routine.
|
|
| statistics.close
| Close the statistics box
|
| statistics.deposit
| Enter a new BAT into the statistics box
|
| statistics.destroy
| Destroy the statistics box
|
| statistics.discard
| Release a BAT variable from the box
|
| statistics.dump
| Display the statistics table
|
| statistics.epilogue
| Release the resources of the statistics package
|
statistics.forceUpdate
|
| Bring the statistics up to date for one BAT
|
| statistics.getCount
| Return latest stored count information
|
statistics.getHistogram
|
| Return the latest histogram
|
| statistics.getHotset
| Return a table with BAT names that have been touched
since the start of the session
|
| statistics.getMax
| Return latest stored maximum information
|
| statistics.getMin
| Return latest stored minimum information
|
statistics.getObjects
|
| Return a table with BAT names managed
|
| statistics.getSize
| Return latest stored count information
|
statistics.hasMoreElements
|
| Locate next element in the box
|
statistics.newIterator
|
| Locate next element in the box
|
| statistics.open
| Locate and open the statistics box
|
| statistics.prelude
| Initialize the statistics package
|
| statistics.release
| Release a single BAT from the box
|
statistics.releaseAll
|
| Release all variables in the box
|
| statistics.take
| Take a variable out of the statistics box
|
| statistics.toString
| Get the string representation of an element in the box
|
| statistics.update
| Check for stale information
|
|
| status.batStatistics
| Show distribution of bats by kind
|
| status.cpuStatistics
| Global cpu usage information
|
| status.getDatabases
| Produce a list of known databases in the current dbfarm
|
| status.getPorts
| Produce a list of default ports for a specific language
|
| status.getThreads
| Produce overview of active threads.
|
| status.ioStatistics
| Global IO activity information
|
| status.memStatistics
| Global memory usage information
|
| status.memUsage
| Get a split-up of how much memory blocks are in use.
|
| status.mem_cursize
| The amount of physical swapspace in KB that is currently in use.
|
| status.mem_maxsize
| Set the maximum usable amount of physical swapspace in KB.
|
| status.vmStatistics
| Get a split-up of how much virtual memory blocks are in use.
|
| status.vm_cursize
| the amount of logical VM space in KB that is currently in use
|
| status.vm_maxsize
| set the maximum usable amount of physical swapspace in KB
|
|
| str.+
| Concatenate two strings.
|
str.STRepilogue
|
str.STRprelude
|
| str.ascii
| Return unicode of head of string
|
| str.chrAt
| String array lookup operation.
|
| str.codeset
| Return the locale's codeset
|
| str.endsWith
| Suffix check.
|
| str.iconv
| String codeset conversion
|
| str.insert
| Insert a string into another
|
| str.length
| Return the length of a string.
|
| str.like
| SQL pattern match function
|
| str.locate
| Locate the start position of a string
|
| str.ltrim
| Strip whitespaces from start of a string.
|
| str.nbytes
| Return the string length in bytes.
|
| str.prefix
| Extract the prefix of a given length
|
| str.r_search
| Reverse search for a char. Returns
position, -1 if not found.
|
str.repeat
|
| str.replace
| Insert a string into another
|
| str.rtrim
| Strip whitespaces from end of a string.
|
| str.search
| Search for a character. Returns
position, -1 if not found.
|
str.space
|
| str.startsWith
| Prefix check.
|
| str.str
| Noop routine.
|
| str.string
| Return substring s[offset..offset+count] of a string s[0..n]
|
str.stringleft
|
| str.stringlength
| Return the length of a right trimed string (SQL semantics).
|
str.stringright
|
| str.substitute
| Substitute first occurrence of 'src' by
'dst'. Iff repeated = true this is
repeated while 'src' can be found in the
result string. In order to prevent
recursion and result strings of unlimited
size, repeating is only done iff src is
not a substring of dst.
|
| str.substring
| Extract a substring from str starting at start, for length len
|
| str.suffix
| Extract the suffix of a given length
|
| str.toLower
| Convert a string to lower case.
|
| str.toUpper
| Convert a string to upper case.
|
| str.trim
| Strip whitespaces around a string.
|
| str.unicode
| convert a unicode to a character.
|
| str.unicodeAt
| get a unicode character
(as an int) from a string position.
|
|
| streams.blocked
| open a block based stream
|
| streams.close
| close and destroy the stream s
|
| streams.flush
| flush the stream
|
| streams.openRead
| convert an ascii stream to binary
|
streams.openReadBytes
|
| open a file stream for reading
|
| streams.openWrite
| convert an ascii stream to binary
|
streams.openWriteBytes
|
| open a file stream for writing
|
| streams.readInt
| read integer data from the stream
|
| streams.readStr
| read string data from the stream
|
| streams.socketRead
| open ascii socket stream for reading
|
streams.socketReadBytes
|
| open a socket stream for reading
|
| streams.socketWrite
| open ascii socket stream for writing
|
streams.socketWriteBytes
|
| open a socket stream for writing
|
| streams.writeInt
| write data on the stream
|
| streams.writeStr
| write data on the stream
|
|
| tablet.display
| Display a formatted table
|
| tablet.dump
| Print all pages with header to a stream
|
| tablet.finish
| Free the storage space of the report descriptor
|
| tablet.firstPage
| Produce the first page of output
|
| tablet.getPage
| Produce the i-th page of output
|
| tablet.getPageCnt
| Return the size in number of pages
|
| tablet.header
| Display the minimal header for the table
|
| tablet.input
| Load a bat using specific format.
|
| tablet.lastPage
| Produce the last page of output
|
| tablet.load
| Load a bat using specific format.
|
| tablet.nextPage
| Produce the next page of output
|
| tablet.output
| Send the bat to an output stream.
|
| tablet.page
| Display all pages at once without header
|
| tablet.prevPage
| Produce the prev page of output
|
| tablet.setBracket
| Format the brackets around a field
|
| tablet.setColumn
| Bind i-th output column to a variable
|
| tablet.setComplaints
| The comlaints bat identifies all erroneous lines encountered
|
| tablet.setDecimal
| Set the scale and precision for numeric values
|
| tablet.setDelimiter
| Set the column separator.
|
| tablet.setFormat
| Initialize a new reporting structure.
|
| tablet.setName
| Set the display name for a given column
|
| tablet.setNull
| Set the display format for a null value for a given column
|
| tablet.setPivot
| The pivot bat identifies the tuples of interest. The only requirement
is that all keys mentioned in the pivot tail exist in all BAT parameters
of the print comment. The pivot also provides control over the order
in which the tuples are produced.
|
| tablet.setPosition
| Set the character position to use for this field when loading according to
fixed (punch-card) layout.
|
| tablet.setProperties
| Define the set of properties
|
| tablet.setRowBracket
| Format the brackets around a row
|
| tablet.setStream
| Redirect the output to a stream.
|
tablet.setTableBracket
|
| Format the brackets around a table
|
| tablet.setTryAll
| Skip error lines and assemble an error report
|
| tablet.setWidth
| Set the maximal display witdh for a given column. All values exceeding
the length are simple shortened without any notice.
|
|
| timestamp.!=
| Equality of two timestamps
|
| timestamp.<
| Equality of two timestamps
|
| timestamp.<=
| Equality of two timestamps
|
| timestamp.==
| Equality of two timestamps
|
| timestamp.>
| Equality of two timestamps
|
| timestamp.>=
| Equality of two timestamps
|
| timestamp.epoch
| convert seconds since epoch into a timestamp
|
| timestamp.isnil
| Nil test for timestamp value
|
| timestamp.unix_epoch
| The Unix epoch time (00:00:00 UTC on January 1, 1970)
|
|
timezone.str
|
| timezone.timestamp
| Utility function to create a timestamp from a number of seconds since the Unix epoch
|
|
| transaction.abort
| Abort changes in certain BATs.
|
| transaction.alpha
| List insertions since last commit.
|
| transaction.clean
| Declare a BAT clean without flushing to disk.
|
| transaction.commit
| Commit changes in certain BATs.
|
| transaction.delta
| List deletions since last commit.
|
| transaction.prev
| The previous stae of this BAT
|
transaction.subcommit
|
| commit only a set of BATnames, passed in the tail
(to which you must have exclusive access!)
|
| transaction.sync
| Save all persistent BATs
|
|
| txtsim.editdistance
| Alias for Levenshtein(str,str)
|
| txtsim.editdistance2
| Calculates Levenshtein distance (edit distance) between two strings. Cost of transposition is 1 instead of 2
|
| txtsim.levenshtein
| Calculates Levenshtein distance (edit distance) between two strings
|
txtsim.qgramnormalize
|
| 'Normalizes' strings (eg. toUpper and replaces non-alphanumerics with one space
|
| txtsim.qgramselfjoin
| QGram self-join on ordered(!) qgram tables and sub-ordered q-gram positions
|
| txtsim.similarity
| Normalized edit distance between two strings
|
| txtsim.soundex
| Soundex function for phonetic matching
|
txtsim.str2qgrams
|
| txtsim.stringdiff
| calculate the soundexed editdistance
|
|
| unix.getenv
| Get the environment variable string.
|
| unix.setenv
| Set the environment variable string.
|
|
| url.getAnchor
| Extract the URL anchor (reference)
|
| url.getBasename
| Extract the URL base file name
|
| url.getContent
| Get the URL resource in a local file
|
| url.getContext
| Get the path context of a URL
|
| url.getDirectory
| Extract directory names from the URL
|
| url.getDomain
| Extract Internet domain from the URL
|
| url.getExtension
| Extract the file extension of the URL
|
| url.getFile
| Extract the last file name of the URL
|
| url.getHost
| Extract the server name from the URL
|
| url.getPort
| Extract the port id from the URL
|
| url.getProtocol
| Extract the protocol from the URL
|
| url.getQuery
| Extract the query string from the URL
|
| url.getQueryArg
| Extract argument mappings from the URL
|
| url.getRobotURL
| Extract the location of the robot control file
|
| url.getUser
| Extract the user identity from the URL
|
| url.isaURL
| Check conformity of the URL syntax
|
| url.new
| Construct URL from protocol, host,and file
|
| url.url
| Create an URL from a string literal
|
|
user.main
|
|
| zrule.define
| Introduce a synomym timezone rule.
|
