CybeResearch

Template-Axiom-Query (TAQ)

CybeResearch Home » Map and Select » Select

Map and Select

A map operation attempts to pair a key to an associated value, for example mapping a country code to a country. A select operation goes further by allowing an entire row of a table to be associated with a key, for example selection by country code of country, capital and surface area in one hit. As part of either operation, the key can be evaluated by an expression, opening up the ability to work with ranges of values, regular expressions and other possibilities.

Proto Select

proto-select.taqt illustrates the design pattern that both nap and select follow. The program maps a bank account number of 1, 2 or 3 into type "sav", "cre" and "chq" respectively. The "map_account" flow features a number match criterion for each account and an "accounts" axiom list to provide the text account values

flow map_account
{ integer account,

integer i,
axiom list accounts(account_type)
{ "sav" }
{ "cre" }
{ "chq" }

}
( account_type,

{

?: account == 1,
++i,
?: account == 2,
++i,
?: account == 3,
i = -1,
?: false

},
? i != -1
{ account_type = accounts[i] }

)

A selection index, "i" is the link between the account number and the account type. A final criterion ?: false provides an exit for the default case of the account number is unrecognized. Both the actual map and select formats require only the axiom list terms and criteria to be programmed while hiding the other implementation details.

Map

Here is an actual account type map:

map account {
? 1: "sav"
? 2: "cre"
? 3: "chq"
}

The map keyword is followed by key "account", which is expected to be local variable containing either 1, 2 or 3. The map format allows the subject of each criteria to be omitted if it is the key. The ==: operator can also be dropped if diong a comparison, Hence ? 1: for the first criteria instead of ? account == 1:.

Select

Both Map and Select create a matrix, the first column being a template, on it's side and with every term a criterion. The remaining columns consist of an axiom list where every axiom is a value mapped by the adjoining criterion. A map axiom contains a single term, while a select axiom has 2 or more terms. The select matrix may be cumbersome to lay out in a template term, so it is declared separately from the select operation.

Select Declaration

Here is the select declaration from bank-accounts.taq. It's axiom list consists of two terms, the first is the name of a bank and the second is a 6-digit code to identify a particular branch

select bank

(	Prefix,	Bank,	BSB	)
{
	? "456448":	"Bank of Queensland",	"124-001",
	? "456443":	"Bendigo Bank LTD",	"633-000",
	? "456445":	"Commonwealth Bank Aust.",	"527-146",
}

Select Operation

A select operation is performed by making a function call. At least one parameter is required to provide the key to match on, The function returns an axiom. In bank-accounts.taq, the returned axiom of the "bank" select function is assigned to a variable named ""

axiom profile = bank(prefix),
bank = profile->Bank,
bsb = profile->BSB

The result for prefix 456443:

prefix=456443, bank=Bendigo Bank LTD, bsb=633-000, accountType=chq

The select operation can also set previously declared variables as an alternative approach. In this case, the function is invoked using the flow. This is a rule for any function that not occur on the right hand side of an expression.

Select Index

The index of the last select operation can be read using object method "index()". If none of the criteria are matched, then the index value is -1. The index for a select operation named "account", for example, would be account.index()

Map is never used in isolation but is always placed on the right-hand side of a variable assignment. Here is an example of a template containing a map statement:

account_type =

map account
{
? 1: "sav"
? 2: "cre"
? 3: "chq"
}

Default Selection

The default case, if applicable, can be dealt with in one of 3 ways:

Set the map result variable to the default value before the map statement.
Have a final criterion for "everything else" such as ? true:
Check the fact status of the variable holding the map result and branch accordingly

Grouping with List Map

Assigning a map to a list variable is supported and allows grouping to be performed in a single pass of the input data. The constraints are that the keyword combination list map must be used to distinguish the map from an ordinary one, and each selection must be an identifier of a previously declared list. dynamic-grouping.taq groups cities by continent using a list map pointing to 5 export dynamic axiom lists (asia, africa, europe ...), one for each continent:

mega_city = list map Continent

{
? "Asia": asia
? "Africa": africa
? "Europe": europe
? "South America": south_america
? "North America": north_america
}

The application displays cities grouped in turn by continent.

Next: Select ...

Skip to Functions ...

Select Header

The select header must specify a term name for each column of the select matrix. However, the significance of the first name is different from the rest as it should match the name of the key, but can be any suitable identifier. The remaining names relate to the axiom list values and these can double as identifiers for previously declared variables. The concept is that as an alternative to collecting the selection result in a axiom, it can also be returned in variables for immediate use in expressions. The variables can also be preset to values for the default case.

color-swatch.taq demonstrates the full use of select variables. It declares a "swatch" select to convert a color represented as a 32-bit value into it's red-green-blue components and gives the color a name. The final criterion of the the select assigns a default color named "unknown":

select swatch

(	color32,	color,	red	green	blue	)
{
	? 0x00FFFF:	"aqua",	0,	255,	255
	? 0x000000:	"black",	0,	0,	0
	? 0x0000FF:	"blue",	0,	0,	255
	? 0xFFFFFF:	"white",	255,	255,	255
	?? true:	"unknown",	0,	0,	0
}

The "shade" template uses 4 variables to hold the selected values and therefore does not make use of the select returned value.

Now there is no assignment to an axiom, the keyword "flow" is placed in front of the "swatch" function call in order to create a valid expression.

...
string color,
integer red,
integer green,
integer blue,
flow swatch(rgb),

Extra Select Parameters

The function of a select operation can be passed more than one parameter. The additional parameters allow the values of select variables to be overriden for sake of customization. Typically each parameter is given a name matching one in the select header, though match by position takes place if anonymous parameters are used.

Prev: Proto Select ...

Next: Branch on Success ...

(	amount,	threshold,	base	percent	)
{
	? > 500000:	500000,	21330.00,	5.50
	? > 300000:	300000,	11330.00,	5.00
	? > 250000:	250000,	8955.00,	4.75
	? > 200000:	200000,	6830.00,	4.25
	? > 100000	100000,	2830.00,	4.00
	? > 50000:	50000,	1080.00,	3.50
	? > 30000:	30000,	480.00,	3.00
	? > 12000:	12000,	120.00,	2.00
	? > 5000:	0,	0.00,	>1.00
}