https://www.tutorialspoint.com/
Q Data Types
There are a lot of data types in Q, includingboolean byte short int long
real float
char symbol
date time month minute second
enum
The most common type of data types used is symbol, i.e. type 11, usually 11h indicating atom symbol. The 'h' means it is a short value.
Type in numeric
Frequently check the Atoms: https://code.kx.com/q4m3/2_Basic_Data_Types_Atoms/All types has a name and can be represented by a short number internally
0 list
1 boolean
2 guid
4 byte
5 short
6 int
7 long
8 real
9 float
10 char
11 symbol
12 timestamp
13 month
14 date
15 datetime
16 timespan
17 minute
18 second
19 time
20-76 enums
77 anymap
78-96 mapped list of lists of type t (what the hell is it?)
97 nested sym enum
98 table
99 dictionary
100 lambda
101 unary primitive
102 operator
103 iterator
104 projection
105 composition
106 f'
107 f/
108 f\
109 f':
110 f/:
111 f\:
112 dynamic load
Some important types does not only has a name and a short number, but also has a char number.
* list
b boolean
g guid
x byte
h short
i int
j long
e real
f float
c char
s symbol
p timestamp
m month
d date
z datetime
n timespan
u minute
v second
t time
Comment
/ this is a comment// is more popular
Assignment to variable x
x:0b // boolean 0x:0x // byte 0
x:0h // short 0
x:0i // int 0
x:0j // long 0
x:2010.01.01
Default literal types
type 0 // default -7h longtype 0.0 // default -9h float
type "" // default 10h empty char list
type ` // default -11h symbol
type () // default 0h empty list
type [] // default 101h unary primitive
type 2000.01.01 // -14h date
type 2000.1.1 // `2010.1.1 error
type 00:00:00.000 // -19h time
type 2000.01.01T00:00:00.000 // -15h datetime
What is symbol?
A symbol is equivalent to SQL varchar, Java String, C++ std::string. But dont call it varchar.Atoms vs List
All data types are atoms including a single number, character or symbol and more.A list contains sequence of atoms.
List example
type `appl // -11h, negative means atomtype (`appl;`goog) // 11h, positive means list
type (`appl`goog) // same as above
type `appl`goog // same as above
List Accessing
symbols:(`appl;`goog;`)symbols[0] / `appl
symbols[1] / `goog
symbols[2] / ` empty
symbols 0 / also `appl, square brackets optional
symbols 0 1
type symbols 0 // -11h, atom
type symbols 0 1 // 11h, list
List with different types
data:(1;2;3;`a;`b;`c;(`d;`e);(5;6;7))type data // 0h, list
data
1
2
3
`a
`b
`c
`d`e
5 6 7
String (list of char)
A list of char is loosely called string. Same idea in C char array.
`$"string with spaces" // $"" for string to symbol
type `$"string with spaces" // -11h
"hello"[0] // h, array like
type "hello"[0] // -10h
"01234" 2 4 // "2 4" 10h
The $ dyadic casting operator
How to cast from integer list to float list?
a:1 2 3
$[`float;a] // use type name to cast
$["f";a] // use char number to cast
$[9h;a] // use short number to cast
a:1 2 3
$[`float;a] // use type name to cast
$["f";a] // use char number to cast
$[9h;a] // use short number to cast
Cast String to Symbols
`$("apple";"banana";"orange")
Cast interger to String
string 0 // "0" 10h list of char
Cast String to Non-Symbols
`int$"123" // 49 50 51i, list of ASCII integerr6h$"123" // same as above
"i"$"123" // same as above
"I"$"123" // 123i
Date
KDB+ date is stored as integer number of days since reference date of 2000-01-01 (Sat), allowing negatives. Literal value is YYYY.MM.DD`int$2000.01.01 // 0i means 0 day from 2000-01-01
`year$2000.01.01 // 2000i means year 2000
`mm$2000.01.01 // 1i means January
`dd$2000.01.01 // 1i means day 1
x:2000.01.01
x.year // 2000i
x.mm // 1i
x.dd // 1i
x+1 // add 1 day 2000.01.02
x-1 // minus 1 day 1999.12.31
x%7 // weekday, starting on Saturday 0, Sunday 1, Monday 2 ... Friday 6
Time
KDB+ time is stored as the integer number of milliseconds since midnight. literal value is HH:MM:SS.MSS
`int$00:00:00.000 // 0i means 0ms since midnight
`int$00:00:01.000 // 1000i means 1000ms since midnight
`hh$01:02:03.004 // 1i means 1 hour
`mm$01:02:03.004 // 2i means 2 minutes
`ss$01:02:03.004 // 3i means 3 seconds
x:01:02:03.004
x.hh // 1i
x.mm // 2i
x.ss // 3i
`float$2000.01.01T00:00:00.000 // 0f
`float$2000.01.01T00:06:00.000 // 0.25 means a quarter of day
KBD+ list format is (;;;;;;;) equivalent to JSON [,,,,,,]
count (1;2;3) // 3
(1h;2h;3h) // short list
(1.1;2.2;3.3) // float list
(0b;1b;1b;0b) // boolean list
(`appl;`goog) // symbol list
("a";"b";"c") // char list, i.e. string, printed in "abc"
type enlist 0 // 7h long list
(0) // 0
type (0) // -7h long atom
type 0 // -7h atom
signum type enlist 0 // 1i list
(0,1,2,3)[1] // 1
(0,1,2,3)[2] // 2
q)b:(2 3)
q)c:(a b c)
q)d:(a;b;c)
q)d
1
2 3
`a`b`c
(1;2;3),(4;5;6) // 1 2 3 4 5 6
(1;2;3),4 // 1 2 3 4
1,2,3,4 // 1 2 3 4
q)L
(1 2 3;4 5 6 7)
(`a`b`c;`d`e`f`g;`0`1`2)
("good";"morning")
q)L[;1;]
4 5 6 7
`d`e`f`g
"morning"
q)L[;;2]
3 6
`c`f`2
"or"
Interpret L[;1;] as, Retrieve all items in the second position of each list at the top level.
Interpret L[;;2] as, Retrieve the items in the third position for each list at the second level.
q)d
Name | `John
Age | 36
Sex | "M"
Weight| 60.3
key d // `Name`Age`Sex`Weight
value d // list of `John 36 "M" 60.3
cols d // same as key d
`int$00:00:01.000 // 1000i means 1000ms since midnight
`hh$01:02:03.004 // 1i means 1 hour
`mm$01:02:03.004 // 2i means 2 minutes
`ss$01:02:03.004 // 3i means 3 seconds
x:01:02:03.004
x.hh // 1i
x.mm // 2i
x.ss // 3i
Datetime
KDB+ datetime is stored as the fractional day since 2000.01.01T00:00:00.000`float$2000.01.01T00:00:00.000 // 0f
`float$2000.01.01T00:06:00.000 // 0.25 means a quarter of day
List
KDB+ list is an ordered atoms and other listsKBD+ list format is (;;;;;;;) equivalent to JSON [,,,,,,]
General list
General list means uniform list means list of atoms of same type.The term homogeneous best describes it.count (1;2;3) // 3
(1h;2h;3h) // short list
(1.1;2.2;3.3) // float list
(0b;1b;1b;0b) // boolean list
(`appl;`goog) // symbol list
("a";"b";"c") // char list, i.e. string, printed in "abc"
Single Item List (singleton)
enlist 0 // ,0type enlist 0 // 7h long list
(0) // 0
type (0) // -7h long atom
type 0 // -7h atom
Distinguish an atom with singleton
signum type 0 // -1i atomsignum type enlist 0 // 1i list
List Operation
Indexing
(0,1,2,3)[0] // 0(0,1,2,3)[1] // 1
(0,1,2,3)[2] // 2
Indexed Assignment
L:1 2 3
L[0]:9 // no return value
L[0]:9 // no return value
L // 9 2 3
List from variables
q)a:1q)b:(2 3)
q)c:(a b c)
q)d:(a;b;c)
q)d
1
2 3
`a`b`c
List joining by , operator
The , operator append the right operand to the end of left operand, accepts an atom or atoms.(1;2;3),(4;5;6) // 1 2 3 4 5 6
(1;2;3),4 // 1 2 3 4
1,2,3,4 // 1 2 3 4
Nesting: list of list
count (1;2;(3,4,5)) // 3 items
(1;2;(3,4,5))[2][0] // 3Elided Indices (TBD: understand it more later)
q)L:((1 2 3; 4 5 6 7); (`a`b`c;`d`e`f`g;`0`1`2);("good";"morning"))q)L
(1 2 3;4 5 6 7)
(`a`b`c;`d`e`f`g;`0`1`2)
("good";"morning")
q)L[;1;]
4 5 6 7
`d`e`f`g
"morning"
q)L[;;2]
3 6
`c`f`2
"or"
Interpret L[;1;] as, Retrieve all items in the second position of each list at the top level.
Interpret L[;;2] as, Retrieve the items in the third position for each list at the second level.
Quick Browse (Revisit deeply later)
Dictionary
Create
q)d:`Name`Age`Sex`Weight!(`John;36;"M";60.3)q)d
Name | `John
Age | 36
Sex | "M"
Weight| 60.3
Operation
count d // 4key d // `Name`Age`Sex`Weight
value d // list of `John 36 "M" 60.3
cols d // same as key d
Lookup
d[`Name] // `John
d[`Name`Sex] // list of `John "M"
d[`Name`Sex] // list of `John "M"
Lookup with Verb @
d@`Name // `John
Update and Upsert
d[`Age]:35
d[`Height]:"170cm"
d[`Height]:"170cm"
Reverse Lookup with the find operator ?
d?60.3 // `Weight first item in the domain
Delete entry with the delete operator _
d _`Height
Name | `John
Age | 36
Sex | "M"
Weight| 60.3
Column Dictionary (Table)
End
