Skip to content

Handling nulls and infinities

PyKX and its management of nulls and infinities inherited from q operate differently in subtle ways from familiar libraries such as Numpy.

PyKX provides typed null and infinity values for most types. As shown in the q docs, nulls can be expressed as 0N followed by a type character (or no type character for long integer null), while infinities can be expressed as 0W followed by a type character (or no type character for a long integer infinity).

Datatypes in q designate a particular value in their numeric range as null, and another two as positive and negative infinity. Most other languages, such as Python, have no way to represent infinity for anything other than IEEE floating point numbers, and where typed nulls exist, they will not also be a value in the range of the datatype (save for floats, which can be NaN).

For example, the q null short integer 0Nh is stored as the value -32768 (i.e. the smallest possible signed 16 bit integer), and the q infinite short integer is stored as the value 32767 (i.e the largest possible signed 16 bit integer).

Due to the design of nulls and infinites in q, there are some technical considerations - detailed on this page - regarding converting nulls and infinities between Python and q in either direction.

Generation of null and infinite values

To facilitate the generation of null and infinite values there are a number of properties for pykx.Atom objects which allow this to be completed Pythonically. In all cases this requires access to licensed mode. The following examples show the generation of various null and infinite values.

Null generation

Where possible null values can be returned to you as follows:

>>> import pykx as kx
>>> kx.LongAtom.null
>>> kx.TimespanAtom.null
>>> kx.GUIDAtom.null
>>> kx.SymbolAtom.null

Unsupported values will return a NotImplemetedError as follows:

>>> import pykx as kx
>>> kx.ByteAtom.null
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/anaconda3/lib/python3.8/site-packages/pykx/", line 250, in null
    raise NotImplementedError('Retrieval of null values not supported for this type')
NotImplementedError: Retrieval of null values not supported for this type

Infinite generation

Where possible positive and negative infinite values can be returned to you as follows:

>>> import pykx as kx
>>> kx.TimeAtom.inf
>>> -kx.TimeAtom.inf
>>> kx.IntAtom.inf
>>> -kx.IntAtom.inf

Unsupported values will return a NotImplementedError as follows:

>>> kx.SymbolAtom.inf
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/anaconda3/lib/python3.8/site-packages/pykx/", line 274, in inf
    raise NotImplementedError('Retrieval of infinite values not supported for this type')
NotImplementedError: Retrieval of infinite values not supported for this type

Checking for nulls and infinities

The q function named null can be applied to most PyKX objects, and will return if the object is null by returning 1b, or if it contains nulls by returning a collection of booleans whose shape matches the object. Like with any function from the .q namespace, it can be accessed via the context interface: q.null).

>>> import pykx as kx
>>> kx.q.null(kx.q('0n'))
>>> kx.q.null(('1 2 0n 3f'))

pykx.Atom objects provide the properties is_null and is_inf. These are True if the atom is a null value for its type, or an infinite value (positive or negative) for its type, respectively, and False otherwise. is_inf is always False for types which do not have an infinite value in q, such as symbols.

>>> kx.q('0w').is_inf
>>> kx.q('0W').is_inf
>>> kx.q('1f').is_inf
>>> kx.q('0n').is_null
>>> kx.q('0N').is_null
>>> kx.q('1f').is_null

Likewise, all pykx.Collection objects provide the properties has_nulls and has_infs. They are True if the collection has any nulls/infinities in it.

>>> kx.q('0w,9?1f').has_infs
>>> kx.q('0w,9?1f').has_nulls

Some null values are unintuitive. For instance, the null value for a character in q is the space " ", the null value for a symbol is the empty symbol, and the null value for a GUID is 00000000-0000-0000-0000-000000000000. A char vector (i.e. q string) that has any spaces in it will have has_nulls set to True.

q to Python

Vectors with the q types short, int, and long can be converted to Python in the following ways:

  • .py provides a list with the null values left as pykx.K objects - thin wrappers around the objects in q's memory.
  • .np provides a masked array with the null values masked out, and the fill value set to the underlying value of the q null.
  • .pd provides a Series as per usual, but backed by an IntegerArray instead of a regular np.ndarray.
  • .pa provides a PyArrow Array as per usual, which natively supports nullable integral vector data, so it simply has the indexes of the nulls stored in the array metadata.

Real vectors use the standard NaN and inf values, and so are handled by q, Python, Numpy, Pandas, and PyArrow in the same way with no special handling.

Temporal vectors use NaT to represent null values in Numpy and Pandas, left as pykx.K objects in pure Python, and PyArrow represents null temporal values like it does for any other data type: by masking it out using the array metadata.

When converting a table from q to Python with one of the methods above, each column will be transformed as an independent vector as described above.

The following provides an example of the masked array behavior outlined in the .np method described above which is additionally exhibited by the .pd method.

>>> import pykx as kx
>>> df = kx.q('([] til 10; 0N 5 10 15 0N 20 25 30 0N 35)').pd()
>>> print(df)
   x  x1
0  0  --
1  1   5
2  2  10
3  3  15
4  4  --
5  5  20
6  6  25
7  7  30
8  8  --
9  9  35
>>> kx.toq(df)
x x1
1 5
2 10
3 15
5 20
6 25
7 30
9 35

An important example which represents some of the limitations of Pandas DataFrames when displaying masked arrays in index columns can be seen as follows.

In the example below we are converting a keyed table containing one key column containing nulls to Pandas, as expected when converted the null mask is applied as appropriate

>>> keytab = kx.q.xkey('x',
...     kx.Table(data = {
...         'x': kx.q('1 2 0N'),
...         'x1': kx.q('1 0N 2'),
...         'x3': [1, 2, 3]})
...     )
>>> keytab
x| x1 x3
-| -----
1| 1  1 
2|    2 
 | 2  3 
>>> keytab.pd()
    x1  x3
 1   1   1
 2  --   2
--   2   3

However, when displaying with multi-index columns the mask behaviour is not adhered to, this can be seen as follows

>>> keytab = kx.q.xkey(['x', 'x1'],
...     kx.Table(data = {
...         'x': kx.q('1 2 0N'),
...         'x1': kx.q('1 0N 2'),
...         'x3': [1, 2, 3]})
...     )
>>> keytab
x x1| x3
----| --
1 1 | 1 
2   | 2 
  2 | 3 
>>> keytab.pd()
x                    x1                      
 1                    1                     1
 2                   -9223372036854775808   2
-9223372036854775808  2                     3

To illustrate this as a limitation of Pandas rather than PyKX consider the following

>>> tab = kx.Table(data = {
...         'x': kx.q('1 2 0N'),
...         'x1': kx.q('1 0N 2'),
...         'x3': [1, 2, 3]})
>>> tab
x x1 x3
1 1  1 
2    2 
  2  3 
>>> df = tab.pd()
>>> df
   x  x1  x3
0  1   1   1
1  2  --   2
2 --   2   3
>>> df.set_index(['x'])
    x1  x3
 1   1   1
 2  --   2
--   2   3
>>> df.set_index(['x', 'x1'])
x                    x1                      
 1                    1                     1
 2                   -9223372036854775808   2
-9223372036854775808  2                     3

Additional to the above inconsistency with Pandas you may also run into issues with the visual representations of masked arrays when displayed in Pandas DataFrames containing large numbers of rows, for example consider the following case.

>>> t = kx.q('([] time:.z.p;a:til 1000;b:9,999#0N)')
>>> t.pd()
                                 time    a                    b
0   2023-06-12 01:25:48.178532806    0                    9
1   2023-06-12 01:25:48.178532806    1 -9223372036854775808
2   2023-06-12 01:25:48.178532806    2 -9223372036854775808
3   2023-06-12 01:25:48.178532806    3 -9223372036854775808
4   2023-06-12 01:25:48.178532806    4 -9223372036854775808
..                            ...  ...                  ...
995 2023-06-12 01:25:48.178532806  995 -9223372036854775808
996 2023-06-12 01:25:48.178532806  996 -9223372036854775808
997 2023-06-12 01:25:48.178532806  997 -9223372036854775808
998 2023-06-12 01:25:48.178532806  998 -9223372036854775808
999 2023-06-12 01:25:48.178532806  999 -9223372036854775808

[1000 rows x 3 columns]    

While -9223372036854778080 does represent an underlying PyKX Null value for display purposes visually it is distracting. To display the DataFrame with the masked values you must set it's display.max_rows to be longer than the length of the specified table, the effect of this can be seen as follows.

>>> import pandas as pd
>>> t = kx.q('([] time:.z.p;a:til 1000;b:9,999#0N)')
>>> pd.set_option('display.max_rows', 1000)
>>> t.pd
                          time    a  b
0   2023-11-26 22:16:05.885992    0  9
1   2023-11-26 22:16:05.885992    1 --
2   2023-11-26 22:16:05.885992    2 --
3   2023-11-26 22:16:05.885992    3 --
4   2023-11-26 22:16:05.885992    4 --
5   2023-11-26 22:16:05.885992    5 --

For more information on masked Numpy arrays and interactions with null representation data in Pandas see the following links

Python to q

Wherever practical the conversions from q to Python are symmetric, so most of the conversions detailed in the section above work in reverse too. For instance, if you convert a Numpy masked array with dtype np.int32 to q, the masked values will be represented by int null (0Ni) in q.


By default, whenever PyKX converts a q vector to some Python representation (e.g. a Numpy array) it checks where the nulls (if any) are located. This requires operating on every element of the array, which can be rather expensive. If you know ahead of time that your q vector/table has no nulls in it, you can provide the keyword argument has_nulls=False to .py/.np/.pd/.pa. This will skip the null-check. If you set this keyword argument to false, but there are still nulls in the data, they will come through as the underlying values from q, e.g. -32768 for a short integer.

By default has_nulls is None. It can be set to True to always handle the data as if it contains nulls, regardless of whether it actually does. This can improve consistency in some cases, for instance by having all int vectors be converted to Numpy masked arrays instead of normal Numpy arrays when there are no nulls, and masked arrays when there are nulls.

You can also use the keyword argument raw=True for the py/np/pd/pa methods for improved performance - albeit this affects more than just how nulls are handled. See the performance doc page for more details about raw conversions.

Infinite Weirdness

Other than real/float infinities, which follow the IEEE standard for infinities and so are ignored in this section, infinite values in kdb+ do not behave how you would expect them to. PyKX opts to expose their behavior as-is, since the alternatives (error for infinities, or always expose them as their underlying values) are undesirable. For this reason you should take care when using them.

Arithmetic operations on infinities are applied directly to the underlying values. As such, adding 1 to many positive infinities in q will result in the null for that type, as the value overflows and becomes the smallest value in that type's range. Subtracting 1 from positive infinities merely yields the second largest number for that type. For instance, 2147483646 == q('0Wi') - 1.