exec a!b from tab

It is quite possible that to achieve the same effect I have used something like

(value d)[0]!(value d:exec a,b from tab)[1]


Saying that it is a coding horror is not enough…

Anyway, let’s look at the result of both queries which is exactly the same. However, the second approach is not only longer but also slower…

So what is the result? A dictionary that keys and values are based on columns’ content. In other words exec returns this

tab:([] a:0 1 2 3; b:`a`b`c`d)
exec a!b from tab
0| a
1| b
2| c
3| d

instead of

exec a, b from tab
a| 0 1 2 3
b| a b c d


d:`a`b`c!1 `eo 3.0

you can lookup `b like this

d[`b]
`eo


If you try to access a key that is out of dictionary domain, you will get a null value which type is the same as type of the first value in dictionary, e.g.

d[`outOfDomain]
0N

And now comes a tricky thing. What will happen if the first value is… a table? It has no null value so what kind of result we can expect? Well… a table schema. Similarly, for a dictionary “a null value” is an empty dictionary and for enumeration – an empty list.

d:`a`b`c!(([] c1:til 3;c2:3?`4);`ooo;3.0)

You should be especially aware of that when testing lookup results. If dictionary contains complex types in its range list, using null will not be enough. And you will not get any error.

tab:([] c1:`int$(); c2:`symbol$(); c3:`date$())


or like that

tab:([] c1:0#0N; c2:0#`; c3:0#0Nd)


The second definition is less obvious but… it is still easy to understand if compared to this fancy piece of code

tab:flip (`c1`c2`c3)!"ISD"$\:()

I wonder which of those is used by q-gods

Let’s check which namespaces exist when the process is started:

q) key`
`q`Q`h`o

Moreover, you can use key to list the content of namespace:
q) key `.foo
`init`func`c


Note that in this way we get everything what resides in the namespace but we cannot distinguish between tables, functions and variables. If you need to list only one of these, use \a, \f or \v, e.g.,

q) tab:([] a:1 2 3; b:`a`b`c)
q)\a
,`tab


,0
0 1
0 1 2
0 1 2 3
0 1 2 3 4


Probably your solution would be like this:

til each 1+til 5

But there is also other way which is even faster:

enlist[enlist 0],0,\1+til 4

Well, at least my PC states that it is faster

q> \t do[1000;enlist[enlist 0],0,\1+til 400]
98
q> \t do[1000;til each 1+til 401]
171

Even Nicer Solution

Instead of complicated

enlist[enlist 0],0,\1+til 400

use short and sweet

(,\) til 401

Thanks, Rs!

It seems that this behaviour was implemented to… solve sudoku. The lists it generates corresponds to sudoku array or more precisely – indices of rows and columns.

rotate:{raze reverse (0,$[0>y;count[x]+y;y])_x}

This solution was originally proposed as a comment to P19: Rotate a list N places to the left.

It is well-known that the general form of functional select is:

?[t;c;b;a]

where t is a table, c is a list of constraints, b is a by-phrase (dictionary of grouping specifications) and a is a dictionary of aggregations. However, it can be extended with two more values which let you extract only a subset of table.

The fifth parameter is perfect to extract N elements from the front or end of table. For example, to get first 10 elements use

?[t;c;b;a;10]

which is equal to

10#?[t;c;b;a]

or

select[10] a by b from t where c

And what is the use of sixth parameter? Well, it extracts rows based on the list of indices. For example, to get 1st, 5th and 10th row use

?[t;();0b;();0W;1 5 10]

which is equal to

?[t;();0b;()] 1 5 10

or

?[t;enlist (in;`i;1 5 10);0b;()]


Degenerate form of functional select is then like:

?[t;();0b;();0W;`i]

However, it seems that the use of additional parameters causes lower performance of  functional select. Perhaps it is why they are not mentioned in Q for Mortals?