Composite-Table-Related Functions

The following are composite-table-related functions that handle computations over composite tables that are unique in esProc.

Ø  C

A column in a table, its parent table, or a table above them

Ø  channel(cs)

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

Ø  channel(ch)

Create a cluster channel and push data in another cluster channel into it

Ø  cs.fetch()

Fetch data from a distributed cursor

Ø  cs.group()

Group a cluster cursor by comparing each record with its next neighbor

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

Group a cluster cursor by comparing each record with its next neighbor and then aggregate each group

Ø  cs.groups()

Group the records in a cluster cursor

Ø  cs.groupx()

Group records in a cluster cursor and return result as a synchronously segmented cluster cursor

Ø  cs.join()

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

Ø  cs.joinx()

Join up a cursor and an entity table by the foreign key

Ø  cs.memory()

Generate a memory table from a cursor

Ø  cs.memory()

Generate a cluster memory table from a cluster cursor

Ø  cs.sortx()

Sort data in a cluster cursor

Ø  cs.switch()

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

Ø  f.append()

Concatenate two same-structure composite tables

Ø  f.create()

Open a composite table

Ø  f.create(C:b1,;K:b2;x;pw:pr)

Generate a composite table’s base table from a file

Ø  f.create(C:b1,…;K:b2;x;pw:pr)

Generate a cluster composite table’s base table from a cluster file

Ø  f.reset()

Copy a composite table file to another composite table file

Ø  f.rollback()

Restore a composite table file to the previous state when update error happens

Ø  file(fn,h)

Generate a cluster file from a remote composite table file

Ø  joinx()

Join multiple synchronously segmented cluster cursors/multicursors

Ø  joinx(Ti:Fi,xj,..;…)

Ø  k{}

Join up multiple pseudo tables.

Get certain bytes from a serial byte to form a single-byte serial byte

Ø  k1+k2

Concatenate serial bytes

Ø  k.row

Find one or more records from a memory table according to specified key value(s)

Ø  memory()

Generate a cluster memory table from a local memory table

Ø  T()

Ø  T.append(cs)

Compute the specified expression on each record in a pseudo table

Append records in a cursor/distributed cursor to an attached entity table

Ø  T.attach(T’)

Retrieve an attached table from a cluster composite table

Ø  T.attach(T’,C)

Add an attached table to a composite table’s base table

Ø  T.C

Retrieve a specified column from an attached table

Ø  T.cgroups()

Perform grouping and aggregation over a pre-summarized data cube

Ø  T.close()

Close a composite table file

Ø  T.cuboid()

Store the result set of grouping an entity table as a pre-summarized data cube

Ø  T.cursor(x:C,;wi,...;k:n)

Segment an entity table and return the cursor of a specified segment

Ø  T.cursor(x,...;wi,...)

Return one or more specified columns of a cluster entity table/cluster memory table as a cluster cursor

Ø  T.cursor(x:C,...;wi,...;mcs)

Synchronously segment an entity table according to a multicursor and return a multicursor

Ø  T.cursor(x:C,...;wi,...;mcs)

Synchronously segment a cluster entity table according to a cluster multicursor and return a cluster multicursor

Ø  T.cursor(C,;wi,...;k:n)

Segment a memory table/cluster memory table and return cursor of the specified segment

Ø  T.cursor(...;w;mcs)

Divide a memory table in sync with a memory multicursor and return it also as a memory multicursor

Ø  T.cursor(xi:Ci,…)

Ø  T.delete(P)

Generate a cursor based on data of a pseudo table

Delete specified record(s) from an entity table

Ø  T.delete(P)

Delete specified record(s) from a memory table

Ø  T.delete(P)

Delete specified records from a cluster table

Ø  T.derive()

Add fields of a composite table to a table sequence/cursor according to the latter's key values

Ø  T.derive()

Add fields of a cluster composite table to a table sequence/cursor according to the latter's key values

Ø  T.derive(T’/A/cs,x:C,…;wi,...)

 

Ø  T.derive(xi :Fi,…)

Ø  T.dup()

Add fields of a pseudo table to another pseudo table, a table sequence or a cursor according to the latter’s key values

Add new fields to a pseudo table

Join up cluster memory table into a local memory table

Ø  T.dup(h)

Copy a local memory table onto nodes to create a duplicate cluster memory table

Ø  T.f(C)

Perform an aggregate operation over an attached table’s column

Ø  T.find(k,…)

Find the record(s) according to the specified primary key value(s) from a memory table

Ø  T.find(k;x:C,...)

Find the record(s) according to the specified primary key value(s) from the base table

Ø  T.group(xi,…)

 

Ø  T. groups(x:F,…;y:G…;n)

Ø  T.icursor(C,;w,I)

Group a pseudo table by comparing only neighboring values of the grouping field

Group and summarize records in a pseudo table

Use index to filter an entity table according to the filtering condition

Ø  T.icursor(C,...;w,I)

Use index to filter a cluster table according to the filtering condition

Ø  T.import()

Read in records from an entity table and return them as a sequence, record sequence or table sequence

Ø  T.import(xi:Ci,…)

 

Ø  T.index(I:h,w;C,…;F,…)

Retrieve data from a pseudo table and return it as a table sequence

Create an index file for an entity table

Ø  T.index(n)

Create an index for the key of a memory table

Ø  T.join(C:.,A:K,x:F,…; …;…)

Ø  T.keys()

Join a pseudo table and table sequence/record sequence through the foreign key

Define the key(s) for a memory table

Ø  T.len()

Get the number of records in a memory table

Ø  T.memory()

Convert a compressed memory table into an uncompressed one

Ø  T.memory(C,…;w)

Generate a memory table from an entity table

Ø  T.memory(C,…;w)

Generate a cluster memory table from a cluster entity table

Ø  T.new(A/cs,x:C,...;wi,…)

 Get values of specified field(s) according to key values in a table sequence, record sequence or a cursor and return result as a table sequence or a cursor

Ø  T.new(A/cs,x:C,...;wi,…)

Retrieve specific fields from a cluster composite table according to key values of a table sequence/record sequence or a cursor and return a cluster multicursor

Ø  T.new(T’/A/cs,x:C,…;wi,...)

 

Ø  T.new(xi:Fi,…)

 

 

Ø  T.news(A/cs,x:C,...;wi,...)

Retrieve specified fields from a pseudo table by matching its records with key values of another pseudo table, a table sequence, or a cursor

Compute an expression on a specified field of a pseudo table, assign results to the field and return a new pseudo table

Get values of specified field(s) according to key values in a table sequence or a cursor, concatenate them and return result as a table sequence or a cursor

Ø  T.news(T’/A/cs,x:C,…;wi,...)

 

 

Ø  T.news (X;xi:Fi,…)

 

Ø  f.open(p)

Retrieve specified fields from a pseudo table by matching its records with key values another pseudo table, a table sequence, or a cursor, and join them onto the latter to generate a new pseudo table

Get a computed field based on a records sequence and join it onto a pseudo table

Open a composite table file or a homo-name files group

Ø  f.open(p)

Open a cluster file.

Ø  T.pseudo()

Ø  T.pseudo()

Ø  T.pseudo(n)

 

Ø  T.pseudo(T’)

 

 

Ø  T.rename(F:F’,…)

Generate a pseudo table from an entity table

Generate a cluster pseudo table from a cluster table

Divide a pseudo table into segments and return a multi-threads pseudo table

Align a pseudo table to segments of another pseudo table to divide the former and generate a new segmented pseudo table

Modify a field name or the index name

Ø  T.run(xi:Fi,…)

 

 

Ø  T.select(x)

 

Ø  T.switch(Fi,Ai:x;…)

 

Ø  T.total(y,…)

Ø  T.update(P)

Compute specified expressions on specific fields of each record of a pseudo table and assign results to the same fields

Select records satisfying a specified condition from a pseudo table and return it containing these records

Replace values of a specified field in a pseudo table with a referencing field values

Summarize records of a pseudo table

Update records in an entity table

Ø  T.update(P)

Update records in a memory table

Ø  T.update(P)

Update records in a cluster composite table

Ø  T{x:C,...}

Return an attached table’s records as a sub table sequence