kdb+ Casting and Parsing

Kdb+ provides a large number of data types, below is shown how to convert between types:

kdb+ Data Types
Casting to Convert Types
Parsing Values from Strings

kdb+ Data Types

For reference the kdb+ data types table is reproduced on this page:

type	size	char	num	notation	Null Value	Positive Infinity
Mixed List			0
boolean	1	b	1	1b	0b
byte	1	x	4	0x26	0x00
short	2	h	5	42h	0Nh	0Wh
int	4	i	6	42	0N	0W
long	8	j	7	42j	0Nj	0Wj
real	4	e	8	4.2e	0Ne	0We
float	8	f	9	4.2	0n	0w
char	1	c	10	"z"	" "
symbol		s	11	`zaphod	`
timestamp	8	p	12	2011.07.08D21:48:48.703125000	0Np	0Wp
month	4	m	13	2006.07m	0Nm	0Wm
date	4	d	14	2006.07.21	0Nd	0Wd
datetime	4	z	15	2006.07.21T09:13:39	0Nz	0Wz
timespan	8	n	16	0D21:56:26.421875000	0Nn	0Wn
minute	4	u	17	12:11	0Nu	0Wu
second	4	v	18	12:11:17	0Nv	0Wv
time	4	t	19	09:01:02:042	0Nt	0Wt
enum	4	*	20-77	`u$v
table			98	([] c1:ab`c; c2:10 20 30)
dictionary			99	`a`b`c!!10 20 30

Casting Types

Casting in kdb+ allows converting from one builtin type to another. Casting uses the $ symbol and specifies the type on the left and those values to be converted on the right. There are three variations for specifying castings and specifying the type to be converted to, using:

Name.
Lower Case Character.
Type Number.

These values an be found in the columns "Type", "char" and "num" respectively in the Data Types table shown above. Here are some examples where we convert longs / shorts / floats to the integer type:

q)"i"$3.3
3
q)`int$3.3  / using the full name
3
q)"i"$3.3   / using lower case letter
3
q)6h$3.3   / using type number
3

q)type 3.3
-9h
q)type `int$3.3
-6h

q)/ casting from floating-point to integer uses rounding
q)"i"$9.5
10
q)"i"$9.4
9

Casting Booleans, Chars...

When casting to some types the behaviour may not be intuitive, some rules to take note of are:

When casting to boolean, Zero/0 is false, everything else is true.
When casting from complex types (dates, characters, time..) to numeric values, the numeric value is simply the underlying value of the bytes.
- Dates are stored as the number of days since 1st January 2000, casting to int returns that value.
- Times are stored as the number of milliseconds since midnight, casting to int returns that value.
- Characters are stored as UTF-8, casting returns the underlying UTF-8/ASCII value.

q) / casting to boolean, only 0 is false
q)`boolean$0
0b
q)`boolean$1
1b
q)`boolean$234
1b
q)`boolean$10.1
1b
q)`boolean$0.0
0b

q) / casting to date gives days since 1st January 2000
q)`int$2000.01.15
14
q)`int$2000.02.15
45
q)`int$1999.02.15
-320

q) / casting to time gives milliseconds since midnight
q)`int$11:59:00.000
43140000
q)`int$00:00:01.000
1000
q)`int$00:00:01.001
1001
q)`int$12:00:00.001
43200001
q)12*60*60*1000
43200000

q) / casting to char returns the ASCII value
q)`int$"ABC"
65 66 67

q) / all casting shown above is reversable (bijective)
q)`date$1
2000.01.02
q)`time$1
00:00:00.001
q)`char$65
"A"

Cast Time to Hours, Minutes

A common use of casting is when performing aggregations, often we will want to bucket data stored with millisecond accurate timestamps by minute or second for example: To get the avg price each minute.

q) / Generate an ordered list of random times (millisecond accuracy)
q)lt:`#asc .z.t + 10?100000
q) / casting rounds our values
q)`minute$lt
11:31 11:31 11:32 11:32 11:32 11:32 11:32 11:32 11:33 11:33
q)`second$lt
11:31:49 11:31:49 11:32:05 11:32:09 11:32:11 11:32:24 11:32:45 11:32:55 11:33..

q)t:([] time:lt; price:asc 100.+til 10)
q)t
time         price
------------------
11:31:49.745 100
11:31:49.856 101
11:32:05.188 102
11:32:09.395 103
11:32:11.325 104
11:32:24.285 105
11:32:45.249 106
11:32:55.355 107
11:33:18.703 108
11:33:18.855 109

q)select avg price by `minute$time from t
time | price
-----| -----
11:31| 100.5
11:32| 104.5
11:33| 108.5

Casting Lists

Casting a list of values can be carried out in two ways. By either specifying the same type for all items or specifying a specific type for each item, this behaviour is identical to applying most dyadic functions to a list. q)"f"$2 3 5 6 2 3 5 6f q)"fiij"$2 3 5 6 2f 3 5 6j q)type each "fiij"$2 3 5 6 -9 -6 -6 -7h q)`int$(100.5; 10; 45.2) 101 10 45 q)`int`boolean`float$(100.5; 10; 45.2) 101 1b 45.2

Parsing from Strings

Parsing is the term used for reading strings and converting them to other types. There is only one method of specifying parsing, using the uppercase letter together with the dollar $ operator. If a string is invalid and can't be interpreted as a given type, this will not throw an error, instead the value will be interpreted as null. Parsing a list of strings behaves similar to casting, you can specify one type to use for all parsing or specify individually for each item.

q)l:("1.00001"; "200"; "3.1417")
q)type l
0h
q)type each l
10 10 10h

q)"F"$l
1.00001 200 3.1417
q)type "F"$l
9h

q)"FIF"$l
1.00001
200
3.1417
q)type each "FIF"$l
-9 -6 -9h

q) / invalid parse values are given the value null
q)"D"$("100"; "2013-01-22")
0N 2013.01.22
q)"I"$("100"; "2013-01-22")
100 0N
q)"I"$"3.14" / parsing float to int considered invalid
0N
q)"I"$"3"
3

q) / parsing dates
q)"D"$"2013-01-22"
2013.01.22
q)"ID"$("100"; "2013-01-22")
100
2013.01.22
q)"Z"$"2013.08.16T11:15:44.183"
2013.08.16T11:15:44.183

As shown above, casting and parsing in kdb+ is extremely easy.

Casting is mainly used for storing down values as the most suitable type.
Parsing is used when loading data into kdb+ from file.

Contents