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 members of a cursor sequence and return result as a cursor

Ø  CS.mcursor()

Generate a multicursor based on a sequence of cursors

Ø  CS.merge()

Merge members of a sequence of cursors

Ø  ch.()

Compute a given expression over each member in a channel

Ø  ch.conj()

Split each of the records in a channel, union the members and return the resulting union as a channel

Ø  ch.derive()

Add fields to records in a channel

Ø  ch.fetch()

Fetch and store the existing data in a channel

Ø  ch.fjoin()

Perform foreign-key-style association on a channel

Ø  ch.group()

Group records in a channel by comparing each one with its neighbor(s) and return a 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()

A foreign-key-style join between a channel and a record sequence

Ø  ch.joinx()

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

Ø  ch.new()

Return a channel with newly-computed field values for its records

Ø  ch.news()

Get new values for the fields of records in a channel and update them into the channel

Ø  ch.push()

Push data in a channel into another channel

Ø  ch.result()

Get result of an operation performed in a channel

Ø  ch.run()

Compute an expression against each of the records in a channel and return the channel with new field values

Ø  ch.select()

Return a channel with records that meet the given condition

Ø  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()

Switch the values of a reference field in a channel between the corresponding primary key values and the referenced records, or, sometimes switch between them in a reverse direction

Ø  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)

Compute an expression over each member in the cursor and return results as a 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.derive()

Add one or more fields to a cursor

Ø  cs.fetch()

Fetch one or more records from a cursor

Ø  cs.fjoin()

Perform foreign-key-style association on a cursor

Ø  cs.group()

Group cursor records by comparing only adjacent records and return the original cursor

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

Group records of a given cursor by comparing each with its neighbors, perform aggregation over each group 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)

Group records of a cursor and write 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()

A foreign-key-style join between a cursor and a table sequence/record sequence

Ø  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()

Return a cursor with newly-computed field values for its records

Ø  cs.news()

Compute new cursor field values to update them into the original cursor

Ø  cs.pjoin()

Create association between cursors, or cursor and record sequence through the join key

Ø  cs.push()

Push data in a cursor into a channel

Ø  cs.rename()

Rename a returned field of a cursor

Ø  cs.regex()

Match the string members in a cursor with a regular expression

Ø  cs.reset()

Reset a cursor by moving it back to the beginning

Ø  cs.run()

Compute one or more expressions against each of the records in a cursor and return the modified cursor

Ø  cs.select(x;f)

Write records that not satisfy the specified expression into a bin file

Ø  cs.select()

Return records meeting the given condition from a 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()

Replace values of a specified field in a cursor with the referencing field values of the corresponding record in another table

Ø  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

Ø  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

Ø  mcs.fetch()

Get records from a multicursor

Ø  xjoinx()

Perform cross join over unicursors or table sequences