Cursor Functions

Ø  A.cursor()

Generate a cursor from a sequence

Ø  A.cursor@m(n)

Generate a multicursor from a sequence

Ø  A.cursor@m(mcs,K:K‘,...)

Generate a multicursor segmented synchronously as an existing multicursor using a specified sequence

Ø  CS.conj()

Concatenate cursor members of a sequence and return result as a multicursor

Ø  CS.cursor()

Generate a multicursor using a sequence of cursors

Ø  CS.mcursor()

Generate a multicursor based on a sequence of cursors

Ø  CS.merge()

Merge members of a sequence of cursors and return a multicursor

Ø  ch.()

Attach a computation to a channel and return the orignal channel

Ø  ch.conj()

Attach a computation to a channel, which will split each of its records and perform union on the splitting result

Ø  ch.derive()

Attach a computation that adds one or more fields to a channel and return the original channel 

Ø  ch.fetch()

Fetch and store the existing data in a channel

Ø  ch.fjoin()

Attach a foreign-key-style association on a channel and return the original channel

Ø  ch.group()

Attach an operation of grouping records in a channel by comparing each one with its next and return the original channel

Ø  ch.groupn()

Group records in a channel and push them respectively into a sequence of channels

Ø  ch.groups()

Group records in a channel

Ø  ch.groupx()

Group records in a channel and return a channel

Ø  ch.id()

Generate a channel consisting of values of one or more fields

Ø  ch.iterate()

Perform iterative loop on record sequences in a channel and return the result of the last calculation of a given expression

Ø  ch.join()

Attach a foreign-key-style join with a record sequence to a channel and return the original channel

Ø  ch.joinx()

Join up a channel and a bin file/an entity table according to the foreign key

Ø  ch.new()

Attach a computation of getting field values to a channel and return the original channel

Ø  ch.news()

Generate records according to the given condition, concatenate them into a new table sequence and return it to the original channel

Ø  ch.push()

Push data in a channel into another channel

Ø  ch.result()

Get result of an operation performed in a channel

Ø  ch.run()

Attach a computation that assigns values to a specified field and return the original channel

Ø  ch.select()

Attach a record filtering computation to a channel and return the orignal channel

Ø  ch.select(x,ch’)

Send records in a channel that can’t meet the given condition into another channel

Ø  ch.sortx()

Sort records in a channel

Ø  ch.switch()

Attach a referencing field-based switch operation to a channel and return the original channel

Ø  ch.total()

Perform aggregation over records in a channel

Ø  channel()

Create a channel

Ø  channel(cs)

Create a channel and push data in a specified cursor into it

Ø  channel(ch)

Create a channel and push data in another channel into it

Ø  cs.(x)

Attach the action of computing expression to a cursor and return the original cursor

Ø  cs.close()

Close a cursor

Ø  cs.conj()

Split each of the records in a cursor, union the members and return the original cursor

Ø  cs.cursor@m()

Generate a multicursor using a unicursor

Ø  cs.derive()

Attach the action of adding fields to a cursor and return the original cursor

Ø  cs.fetch()

Fetch one or more records from a cursor

Ø  cs.fjoin()

Attach foreign key style association to a cursor and return the original cursor

Ø  cs.group()

Attach the action of grouping records by comparing only adjacent records to a cursor and return the original cursor

Ø  cs.group(x:F,...;y:G,…)

Attach the action of grouping and aggregating records by comparing only adjacent records to a cursor and return the original cursor

Ø  cs.groupn(x;C)

Group records in a cursor and push them respectively into a sequence of channels

Ø  cs.groupn(x;F)

Attach the grouping record action to a cursor and return the original cursor while writing the grouped subsets to a sequence of bin files

Ø  cs.groups()

Group records in a cursor

Ø  cs.groupx()

Group records in a cursor and return result as a cursor

Ø  cs.id()

Generate a sequence consisting of values of fields in a given cursor

Ø  cs.iterate()

Perform the iterative loop on record sequences in a cursor and return the result of the last calculation of a given expression

Ø  cs.join()

Attach foreign key style join with a record sequence to a cursor and return the original cursor

Ø  cs.joinx()

Join up a cursor and a segmentable bin file according the foreign key

Ø  cs.mcursor()

Generate a multicursor based on one cursor

Ø  cs.new()

Attach the action of computing new field values to a cursor and return the original cursor

Ø  cs.news()

Generate multiple records based on a record sequence, concatenate them into a new table sequence and return it to the original cursor

Ø  cs.pjoin()

Attach the join-key-based association with another cursor or a record sequence to a cursor and return the original cursor

Ø  cs.push()

Push data in a cursor into a channel

Ø  cs.rename()

Rename a returned field of a cursor

Ø  cs.regex()

Attach the action of matchign string members with a regular expression to a cursor and return the original cursor

Ø  cs.reset()

Reset a cursor by moving it back to the beginning

Ø  cs.run()

Attach a computation that assigns values to fields in the cursor to the cursor and return the original cursor

Ø  cs.select(x;f)

Attach the record filtering action to a cursor and return the original cursor while writing records that not satisfy the specified expression to a bin file

Ø  cs.select()

Attach the record filtering action to a cursor and return the original cursor

Ø  cs.select(x,ch')

Send records in a cursor that can’t meet the given condition into a channel

Ø  cs.skip()

Skip records while fetching records from a database cursor, and return the number of skipped records

Ø  cs.sortx()

Sort data in a cursor

Ø  cs.switch()

Attach the action of switching specified field values to the referencing record field values to a cursor and return the original cursor

Ø  cs.total()

Perform aggregation over records in a cursor

Ø  db.cursor()

Create a database cursor by executing an SQL statement

Ø  db.execute()

Execute a SQL statement through a specified database connection

Ø  db.update()

Update a database table according to a cursor

Ø  f.cursor()

Create a cursor based on a file

Ø  f.cursor@m()

Create a multicursor based on a file

Ø  f.export()

Retrieve data from a cursor and write it to a file

Ø  f.iselect()

Create a cursor based on an ordered file and return it

Ø  f.sortx()

Sort a data file or a sequence of files and generate a new file

Ø  joinx()

Join table sequences retrieved from a series of cursors

Ø  mcs.cursor(n)

Merge subcursors in a multicursor into a unicursor or a new multicursor with a smaller number of parallel subcursors

Ø  xjoinx()

Perform cross join over unicursors or table sequences and return a multicursor