Repository: heavyai/rbc (language: python)

Issue:
Rename omnisci to heavydb
With https://github.com/xnd-project/rbc/pull/447, rbc supports two brands of heavydb:
- heavyai: version 6.0 and up
- omnisci: versions 5.x and older

In long term (1-2 years), omnisci brand is going to be deprecated and unsupported.

In short term, we'll need to switch to using heavyai brand name instead of omnisci brand name while still supporting the omniscidb 5.7 and up.

The switch means renaming heavydb related directories and file names as follows [this is a suggestion to be discussed]:
```
rbc/omniscidb.py -> rbc/heavydb.py
rbc/omnisci_backend/ - rbc/heavyai/
rbc/omnisci_backend/omnisci_xyz.py -> rbc/heavyai/xyz.py
rbc/tests/test_omnisci_xyz.py -> rbc/tests/heavyai/test_xyz.py
rbc/externals/omniscidb.py -> rbc/externals/heavydb.py
```

This issue will be actionable after heavydb 6.0 is released and heavydb conda packages will be available.


Discussion / hints:

Fix patch:
diff --git a/README.md b/README.md
index c698a108..c3929314 100644
--- a/README.md
+++ b/README.md
@@ -87,26 +87,26 @@ assert add(1, 2) == 3
 assert add(1.2, 2.3) == 3.5
 ```
 
-### Case 3: Define User Defined Function \(UDF\) in Python and register it in OmnisciDB server
+### Case 3: Define User Defined Function \(UDF\) in Python and register it in HeavyDB server
 
-Assume that OmnisciDB server is running in localhost, for instance.
+Assume that HeavyDB server is running in localhost, for instance.
 
-In a client computer, register a UDF in OmnisciDB server:
+In a client computer, register a UDF in HeavyDB server:
 
 ```text
-from rbc.omniscidb import RemoteOmnisci
-omni = RemoteOmnisci()
+from rbc.heavydb import RemoteHeavyDB
+omni = RemoteHeavyDB()
 @omni('i32(i32)')
 def incr(x):
     return x + 1
 omni.register()
 ```
 
-In a client computer, use the UDF in a query to OmnisciDB server:
+In a client computer, use the UDF in a query to HeavyDB server:
 
 ```text
 import ibis
-con = ibis.omniscidb.connect(...)
+con = ibis.heavydb.connect(...)
 q = con.sql('select i, incr(i) from mytable').execute()
 ```
 
diff --git a/doc/api.rst b/doc/api.rst
index a6360f1d..9c97dc2d 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -18,7 +18,7 @@ Top-level functions
     external
     errors
     libfuncs
-    omniscidb
+    heavydb
     remotejit
     structure_type
     targetinfo
@@ -55,22 +55,22 @@ Externals
     externals.cmath
     externals.libdevice
     externals.macros
-    externals.omniscidb
+    externals.heavydb
     externals.stdio
 
 
-OmniSciDB Backend
+HeavyDB Backend
 =================
 
-The table below contains the data structures available for the OmniSciDB backend.
+The table below contains the data structures available for the HeavyDB backend.
 It should be noticed that the following types are not regular Python types but
 `Numba types <https://numba.readthedocs.io/en/stable/reference/types.html>`__.
 
-The set of types below are only materialize inside the OmniSciDB SQL Engine. Thus,
+The set of types below are only materialize inside the HeavyDB SQL Engine. Thus,
 one cannot create and use them inside the REPL, for instance.
 
 
 .. autosummary::
     :toctree: generated/
 
-    rbc.omnisci_backend.Array
+    rbc.heavyai.Array
diff --git a/doc/omnisci/array.rst b/doc/omnisci/array.rst
deleted file mode 100644
index cac12516..00000000
--- a/doc/omnisci/array.rst
+++ /dev/null
@@ -1,54 +0,0 @@
-﻿.. Omnisci Array:
-
-Array
-=====
-
-.. py:class:: Array<T>
-    
-    In OmniSciDB, an Array with a type `T` is represented as follows:
-
-    .. code-block:: C
-
-        {
-            T* data,
-            int64_t size,
-            int8_t is_null,
-        }
-
-    Array is a contiguous block of memory that behaves like a python list.
-
-    .. rubric:: Methods
-
-    .. py:method:: __init__(self, size: int, dtype: numba.types.Type) -> None
-
-        Creates a new Array with the given size and dtype.
-        Any `scalar <https://numba.readthedocs.io/en/stable/reference/types.html#numbers>`__
-        type is supported as a dtype. 
-
-    .. py:method:: __getitem__(self, idx: int) -> T
-
-    .. py:method:: __setitem__(self, idx: int, value: T) -> None
-
-    .. py:method:: is_null() -> bool
-
-        Checks if the array is null
-
-
-    .. rubric:: Functions
-
-    .. py:function:: len(arr: Array) -> int
-
-        Returns the size property
-
-
-.. code-block:: Python
-
-    from numba import types
-    from rbc.omnisci_backend import Array
-
-    @omnisci('int64[](int64)')
-    def create_and_fill_array(size):
-        arr = Array(size, types.int64)
-        for i in range(size):
-            a[i] = i
-        return a
\ No newline at end of file
diff --git a/doc/omnisci/bytes.rst b/doc/omnisci/bytes.rst
deleted file mode 100644
index c40938d9..00000000
--- a/doc/omnisci/bytes.rst
+++ /dev/null
@@ -1,42 +0,0 @@
-.. Omnisci Bytes:
-
-Bytes
-=====
-
-.. py:class:: Bytes
-
-    In OmniSciDB, Bytes is represented as follows:
-
-    .. code-block:: C
-
-        {
-            char* ptr,
-            int64_t size,  // when non-negative, Bytes has fixed width.
-            int8_t is_null,
-        }
-
-
-    .. rubric:: Methods
-
-    .. py:method:: __init__(self, n: int)
-    .. py:method:: __getitem__(self, idx: int) -> int
-    .. py:method:: __setitem__(self, idx: int, value: int)
-
-    .. rubric:: Functions
-
-    .. py:function:: len(bytes: Bytes) -> int
-
-
-Example
-=======
-
-.. code-block:: python
-
-    from rbc.omnisci_backend import Bytes
-
-    @omnisci('Bytes(int32, int32)')
-    def make_abc(first, n):
-        r = Bytes(n)
-        for i in range(n):
-            r[i] = first + i
-        return r
diff --git a/doc/omnisci/column.rst b/doc/omnisci/column.rst
deleted file mode 100644
index 2f4f5fa9..00000000
--- a/doc/omnisci/column.rst
+++ /dev/null
@@ -1,43 +0,0 @@
-.. Omnisci Column:
-
-.. role:: py(code)
-   :language: python
-
-Column
-======
-
-.. py:class:: Column 
-    
-    In OmniSciDB, a Column with a type `T` is represented as follows:
-
-    .. code-block:: C
-
-        template typename<T>
-        struct Column {
-            T* ptr,           // row data
-            int64_t sz,       // row count
-        }
-
-    Unlike an array, a column cannot be null but its members can.
-
-    .. rubric:: Methods
-
-    .. py:method:: __getitem__(self, idx: int) -> T
-
-        Returns :py:`column[idx]`
-
-    .. py:method:: __setitem__(self, idx: int, value: T) -> None
-
-        Assigns :py:`column[idx] = value`
-
-    .. py:method:: is_null(self, idx: int) -> bool
-
-        Returns if :py:`Column[idx] is None`
-
-    .. py:method:: set_null(self, idx: int) -> None
-
-        Set :py:`Column[idx] = None`
-
-    .. rubric:: Functions
-
-    .. py:function:: len(col: Column) -> int
diff --git a/doc/omnisci/columnlist.rst b/doc/omnisci/columnlist.rst
deleted file mode 100644
index 59e4fcc0..00000000
--- a/doc/omnisci/columnlist.rst
+++ /dev/null
@@ -1,31 +0,0 @@
-.. Omnisci ColumnList:
-
-ColumnList
-==========
-
-.. py:class:: ColumnList
-
-    .. code-block:: C
-
-        template typename<T>
-        struct ColumnList {
-            T** ptrs;   // ptrs to columns data
-            int64_t length;  // the length of columns list
-            int64_t size;    // the size of columns
-        }
- 
-
-    .. rubric:: Methods
-
-    .. py:method:: __getitem__(self, idx: int) -> Column
-
-
-    .. rubric:: Attributes
-
-    .. py:attribute:: ncols -> int
-
-        Returns :py:`ColumnList.length`
-
-    .. py:attribute:: nrows -> int
-
-        Returns :py:`ColumnList.size`
\ No newline at end of file
diff --git a/doc/omnisci/outputcolumn.rst b/doc/omnisci/outputcolumn.rst
deleted file mode 100644
index 629e89c8..00000000
--- a/doc/omnisci/outputcolumn.rst
+++ /dev/null
@@ -1,8 +0,0 @@
-.. Omnisci OutputColumn:
-
-OutputColumn
-============
-
-.. py:class:: OutputColumn(Column) 
-
-    OutputColumn inherits all the methods from :py:class:`Column`.
\ No newline at end of file
diff --git a/docker-compose.yml b/docker-compose.yml
index 6805e8e9..7278d41a 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,8 +1,8 @@
 version: '3'
 services:
 
-  omniscidb:
-    image: ${OMNISCIDB_DOCKER_IMAGE}
+  heavydb:
+    image: ${HEAVYDB_DOCKER_IMAGE}
     ports:
       - 6273:6273
       - 6274:6274
diff --git a/notebooks/rbc-heavydb-array.ipynb b/notebooks/rbc-heavydb-array.ipynb
new file mode 100644
index 00000000..d9cb8339
--- /dev/null
+++ b/notebooks/rbc-heavydb-array.ipynb
@@ -0,0 +1,152 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import warnings; warnings.filterwarnings('ignore')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from rbc.heavydb import RemoteHeavyDB"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# NBVAL_IGNORE_OUTPUT\n",
+    "heavydb = RemoteHeavyDB(user='admin', password='HyperInteractive',\n",
+    "                        host='127.0.0.1', port=6274)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "SQL=lambda query: np.array(list(heavydb.sql_execute(query)[1]), dtype=object)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[array([1, 2, 3, 1], dtype=object)]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "SQL('DROP TABLE IF EXISTS mytable')\n",
+    "SQL('CREATE TABLE IF NOT EXISTS mytable (i INT[]);');\n",
+    "for i in range(5):\n",
+    "    SQL('INSERT INTO mytable VALUES (ARRAY[1,2,3,'+str(i)+'])');\n",
+    "list(SQL('SELECT * FROM mytable')[1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@heavydb('i32(i32[])')\n",
+    "def sum_i32(x):\n",
+    "    s = 0\n",
+    "    for i in range(len(x)):\n",
+    "        s += x[i]\n",
+    "    return s"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[list([1, 2, 3, 0]), 6],\n",
+       "       [list([1, 2, 3, 1]), 7],\n",
+       "       [list([1, 2, 3, 2]), 8],\n",
+       "       [list([1, 2, 3, 3]), 9],\n",
+       "       [list([1, 2, 3, 4]), 10]], dtype=object)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "SQL('SELECT i, sum_i32(i) FROM mytable')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sum_i32['i32(i32[])']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# NBVAL_IGNORE_OUTPUT\n",
+    "print(sum_i32)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/notebooks/rbc-omnisci-black-scholes.ipynb b/notebooks/rbc-heavydb-black-scholes.ipynb
similarity index 98%
rename from notebooks/rbc-omnisci-black-scholes.ipynb
rename to notebooks/rbc-heavydb-black-scholes.ipynb
index fafbaaf0..fd3eb587 100644
--- a/notebooks/rbc-omnisci-black-scholes.ipynb
+++ b/notebooks/rbc-heavydb-black-scholes.ipynb
@@ -4,14 +4,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Example of omniscidb UDF/UDTF: Black-Scholes Model"
+    "# Example of HeavyDB UDF/UDTF: Black-Scholes Model"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The aim of this notebook is to demonstrate how one can enhance OmniSciDB capabilities with UDF (User-Defined Functions) and UDTF (User-Defined Table Functions). For that end, we will demonstrate how one can create, register and invoke UDFs/UDTFs using [RBC](https://github.com/xnd-project/rbc) and [Numba](https://github.com/numba/numba)."
+    "The aim of this notebook is to demonstrate how one can enhance HeavyDB capabilities with UDF (User-Defined Functions) and UDTF (User-Defined Table Functions). For that end, we will demonstrate how one can create, register and invoke UDFs/UDTFs using [RBC](https://github.com/xnd-project/rbc) and [Numba](https://github.com/numba/numba)."
    ]
   },
   {
@@ -73,19 +73,19 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Connecting to the OmniSciDB server"
+    "## Connecting to the HeavyDB server"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Let's establish a connection to the OmniSciDB server"
+    "Let's establish a connection to the HeavyDB server"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -94,14 +94,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Connecting to OmnisciDB version (5, 6, 0, 'dev-20210111-4d09fe77b2')\n"
+      "Running with rbc version 0.7.3+4.gaeb2ae6.dirty\n",
+      "Connecting to HeavyDB version (6, 1, 0, 'dev-20220323-6ced1de2b0')\n"
      ]
     }
    ],
@@ -109,18 +110,18 @@
     "# NBVAL_IGNORE_OUTPUT\n",
     "import rbc\n",
     "print(f'Running with rbc version {rbc.__version__}')\n",
-    "from rbc.omniscidb import RemoteOmnisci\n",
-    "omnisci = RemoteOmnisci(user='admin', password='HyperInteractive',\n",
-    "                     host='127.0.0.1', port=6274, dbname='omnisci')\n",
-    "print(f'Connecting to OmnisciDB version {omnisci.version}')\n",
-    "assert omnisci.version[:3] >= (5, 4, 0), omnisci.version"
+    "from rbc.heavydb import RemoteHeavyDB\n",
+    "heavydb = RemoteHeavyDB(user='admin', password='HyperInteractive',\n",
+    "                        host='127.0.0.1', port=6274)\n",
+    "print(f'Connecting to HeavyDB version {heavydb.version}')\n",
+    "assert heavydb.version[:3] >= (5, 4, 0), heavydb.version"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This notebook requires OmnisciDB version 5.4 or newer and rbc version 0.4 or newer. If the above fails or one is connected to older version of OmnisciDB, please resolve the issue before continuing."
+    "This notebook requires HeavyDB version 5.4 or newer and rbc version 0.4 or newer. If the above fails or one is connected to older version of HeavyDB, please resolve the issue before continuing."
    ]
   },
   {
@@ -147,7 +148,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -244,7 +245,7 @@
        "1529   1530   2.0  0.059524   125.0  11.3580  100.0  0.0"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -270,11 +271,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
-    "SQL=lambda query: list(omnisci.sql_execute(query)[1])\n",
+    "SQL=lambda query: list(heavydb.sql_execute(query)[1])\n",
     "SQL('drop table if exists black_scholes')\n",
     "SQL('create table if not exists black_scholes ('\n",
     "    ' S DOUBLE, X DOUBLE, T DOUBLE, r DOUBLE,'\n",
@@ -290,7 +291,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -300,7 +301,7 @@
     "r = df['r']\n",
     "sigma = df['VLTY']\n",
     "OPRICE = df['OPRICE']\n",
-    "omnisci.load_table_columnar('black_scholes', S=S, X=X, T=T, r=r, sigma=sigma, OPRICE=OPRICE)"
+    "heavydb.load_table_columnar('black_scholes', S=S, X=X, T=T, r=r, sigma=sigma, OPRICE=OPRICE)"
    ]
   },
   {
@@ -312,7 +313,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -391,7 +392,7 @@
        "1529   125.0  0.059524   2.0  11.3580"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -404,7 +405,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -438,33 +439,33 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "OmnisciDB server v5.4 implements support for users to define UDFs and UDTFs. The former applies a function to a table data row-by-row while the latter is applied to an entire column."
+    "HeavyDB server v5.4 implements support for users to define UDFs and UDTFs. The former applies a function to a table data row-by-row while the latter is applied to an entire column."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The UDFs and table functions can be defined as Python functions using the [RBC](https://github.com/xnd-project/rbc/) tool that exploits [Numba](https://github.com/numba/numba) to convert Python functions to [LLVM intermediate representation](https://en.wikipedia.org/wiki/LLVM) and these are registered in the OmnisciDB server."
+    "The UDFs and table functions can be defined as Python functions using the [RBC](https://github.com/xnd-project/rbc/) tool that exploits [Numba](https://github.com/numba/numba) to convert Python functions to [LLVM intermediate representation](https://en.wikipedia.org/wiki/LLVM) and these are registered in the HeavyDB server."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Compute the Black-Scholes model remotely using OmnisciDB UDFs"
+    "## Compute the Black-Scholes model remotely using HeavyDB UDFs"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The following cells will register a function to be called from inside omniscidb"
+    "The following cells will register a function to be called from inside HeavyDB"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -477,12 +478,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Define a standard normal CDF using `@numba.njit` decorator that allows calling the CDF from Omnisci UDF/UDTFs:"
+    "Define a standard normal CDF using `@numba.njit` decorator that allows calling the CDF from HeavyDB UDF/UDTFs:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -506,19 +507,19 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next, we'll define a function `black_scholes_UDF` that evaluates the Black-Scholes formula. The function will be registered with Omnisci server so that one can use it in a SQL query. Notice the `@omnisci` decorator takes the signature of the function as argument:\n",
-    "- `@omnisci(<signature string>)` or `@omnisci(<list of signature strings>)`\n",
+    "Next, we'll define a function `black_scholes_UDF` that evaluates the Black-Scholes formula. The function will be registered with HeavyDB server so that one can use it in a SQL query. Notice the `@heavydb` decorator takes the signature of the function as argument:\n",
+    "- `@heavydb(<signature string>)` or `@heavydb(<list of signature strings>)`\n",
     "\n",
     "In the example below, `black_scholes_UDT` accepts five `double` arguments `(S, X, T, r, sigma)` and returns a `double` value:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
-    "@omnisci('double(double, double, double, double, double)')\n",
+    "@heavydb('double(double, double, double, double, double)')\n",
     "def black_scholes_UDF(S, X, T, r, sigma):\n",
     "    d1 = (np.log(S/X) + (r + 0.5 * sigma**2)*T) / (sigma * np.sqrt(T))\n",
     "    d2 = d1 - sigma * np.sqrt(T)\n",
@@ -536,12 +537,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The following cell illustrates a usage of `black_scholes_UDF` in a SQL query to Omnisci server and compares the results with expected model values:"
+    "The following cell illustrates a usage of `black_scholes_UDF` in a SQL query to HeavyDB server and compares the results with expected model values:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
@@ -567,12 +568,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -596,7 +597,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Compute the Black-Scholes model remotely using OmnisciDB UDTFs"
+    "## Compute the Black-Scholes model remotely using HeavyDB UDTFs"
    ]
   },
   {
@@ -612,11 +613,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
-    "@omnisci('int32(Column<double>, Column<double>, Column<double>, Column<double>, Column<double>,'\n",
+    "@heavydb('int32(Column<double>, Column<double>, Column<double>, Column<double>, Column<double>,'\n",
     "         ' RowMultiplier, OutputColumn<double>)')\n",
     "def black_scholes_udtf(S, X, T, r, sigma, m, out):\n",
     "    input_row_count = len(X)\n",
@@ -638,7 +639,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
@@ -668,12 +669,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -710,7 +711,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.6"
+   "version": "3.8.12"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/rbc-omnisci-external-fns.ipynb b/notebooks/rbc-heavydb-external-fns.ipynb
similarity index 61%
rename from notebooks/rbc-omnisci-external-fns.ipynb
rename to notebooks/rbc-heavydb-external-fns.ipynb
index 2f2917c9..714d5b85 100644
--- a/notebooks/rbc-omnisci-external-fns.ipynb
+++ b/notebooks/rbc-heavydb-external-fns.ipynb
@@ -2,88 +2,85 @@
  "cells": [
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "## Example of RBC `external` function"
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "The `external` feature provides a way of calling external functions from UDF/UDTFs."
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
-    "As a starting point of this notebook, let's connect to the OmniSciDB server and insert some test data"
-   ],
-   "metadata": {}
+    "As a starting point of this notebook, let's connect to the HeavyDB server and insert some test data"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "import numpy as np"
-   ],
-   "outputs": [],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "source": [
-    "from rbc.omniscidb import RemoteOmnisci"
-   ],
+   "execution_count": 3,
+   "metadata": {},
    "outputs": [],
-   "metadata": {}
+   "source": [
+    "from rbc.heavydb import RemoteHeavyDB"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "source": [
-    "omnisci = RemoteOmnisci(user='admin', password='HyperInteractive',\n",
-    "                        host='127.0.0.1', port=6274, dbname='omnisci')"
-   ],
+   "execution_count": 4,
+   "metadata": {},
    "outputs": [],
-   "metadata": {}
+   "source": [
+    "heavydb = RemoteHeavyDB(user='admin', password='HyperInteractive',\n",
+    "                        host='127.0.0.1', port=6274)"
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "### Now, let's insert some test data..."
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "Which consists of 5 negative integers "
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
    "source": [
-    "SQL=lambda query: np.array(list(omnisci.sql_execute(query)[1]))\n",
+    "SQL=lambda query: np.array(list(heavydb.sql_execute(query)[1]))\n",
     "SQL('DROP TABLE IF EXISTS test_data');\n",
     "SQL('CREATE TABLE IF NOT EXISTS test_data (X BIGINT)')\n",
-    "omnisci.load_table_columnar('test_data', X=[-1, -2, -3, -4, -5])"
-   ],
-   "outputs": [],
-   "metadata": {}
+    "heavydb.load_table_columnar('test_data', X=[-1, -2, -3, -4, -5])"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "source": [
-    "SQL('SELECT * FROM test_data')"
-   ],
+   "execution_count": 6,
+   "metadata": {},
    "outputs": [
     {
-     "output_type": "execute_result",
      "data": {
       "text/plain": [
        "array([[-1],\n",
@@ -93,28 +90,32 @@
        "       [-5]])"
       ]
      },
+     "execution_count": 6,
      "metadata": {},
-     "execution_count": 12
+     "output_type": "execute_result"
     }
    ],
-   "metadata": {}
+   "source": [
+    "SQL('SELECT * FROM test_data')"
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "## Declare and use external functions"
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "RBC defines a helper function `external` which can be used to define and call external functions. e.g. function defined by the server, an external library or from the C standard library. It expects the function declaration in the following forms:"
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "#### As a C function declaration:\n",
     "\n",
@@ -122,11 +123,11 @@
     "from rbc.external import external\n",
     "fn = external('int64 abs(int64)')\n",
     "```"
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "#### Function name using a keyword argument\n",
     "\n",
@@ -134,11 +135,11 @@
     "from rbc.external import external\n",
     "fn = external('int64(int64)', name='abs')\n",
     "```"
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "#### A list of signatures\n",
     "\n",
@@ -146,71 +147,67 @@
     "from rbc.external import external\n",
     "fn = external(['i32(i32)', 'i64(i64)'], name='abs')\n",
     "```"
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "## Usage"
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "One can use external function from any jitted functions. For instance, let's define and use the `abs` function from the `cmath` library:"
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "from rbc.external import external\n",
     "abs = external('int64 abs(int64)')"
-   ],
-   "outputs": [],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "Let's now declare a function that uses the `abs`"
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
    "source": [
-    "@omnisci('int64(int64)')\n",
+    "@heavydb('int64(int64)')\n",
     "def use_abs(i):\n",
     "    return abs(i)"
-   ],
-   "outputs": [],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "result = SQL('SELECT X, use_abs(X) FROM test_data')"
-   ],
-   "outputs": [],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
-   "source": [
-    "for r, v in result:\n",
-    "    print(f'abs({r}) = {v}')"
-   ],
+   "execution_count": 10,
+   "metadata": {},
    "outputs": [
     {
-     "output_type": "stream",
      "name": "stdout",
+     "output_type": "stream",
      "text": [
       "abs(-1) = 1\n",
       "abs(-2) = 2\n",
@@ -220,44 +217,47 @@
      ]
     }
    ],
-   "metadata": {}
+   "source": [
+    "for r, v in result:\n",
+    "    print(f'abs({r}) = {v}')"
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "## Caveats"
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "Notice that `abs` is not callable from pure python"
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
-   "source": [
-    "# NBVAL_RAISES_EXCEPTION\n",
-    "abs(-3)"
-   ],
+   "execution_count": 11,
+   "metadata": {},
    "outputs": [
     {
-     "output_type": "error",
      "ename": "NotImplementedError",
      "evalue": "abs is not usable in pure-python",
+     "output_type": "error",
      "traceback": [
       "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
       "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-32-200e9d0206bf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;32m/home/guilhermel/git/rbc/rbc/external.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m     64\u001b[0m         \"\"\"\n\u001b[1;32m     65\u001b[0m         \u001b[0mmsg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34mf\"{self.name} is not usable in pure-python\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmsg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     68\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[1;32m/home/guilhermeleobas/git/rbc/notebooks/rbc-heavydb-external-fns.ipynb Cell 25'\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      <a href='vscode-notebook-cell://wsl%2Bubuntu-20.04/home/guilhermeleobas/git/rbc/notebooks/rbc-heavydb-external-fns.ipynb#ch0000024vscode-remote?line=0'>1</a>\u001b[0m \u001b[39m# NBVAL_RAISES_EXCEPTION\u001b[39;00m\n\u001b[0;32m----> <a href='vscode-notebook-cell://wsl%2Bubuntu-20.04/home/guilhermeleobas/git/rbc/notebooks/rbc-heavydb-external-fns.ipynb#ch0000024vscode-remote?line=1'>2</a>\u001b[0m \u001b[39mabs\u001b[39;49m(\u001b[39m-\u001b[39;49m\u001b[39m3\u001b[39;49m)\n",
+      "File \u001b[0;32m~/git/rbc/rbc/external.py:138\u001b[0m, in \u001b[0;36mExternal.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    <a href='file:///home/guilhermeleobas/git/rbc/rbc/external.py?line=133'>134</a>\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    <a href='file:///home/guilhermeleobas/git/rbc/rbc/external.py?line=134'>135</a>\u001b[0m \u001b[39mThis is only defined to pretend to be a callable from CPython.\u001b[39;00m\n\u001b[1;32m    <a href='file:///home/guilhermeleobas/git/rbc/rbc/external.py?line=135'>136</a>\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    <a href='file:///home/guilhermeleobas/git/rbc/rbc/external.py?line=136'>137</a>\u001b[0m msg \u001b[39m=\u001b[39m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mname\u001b[39m}\u001b[39;00m\u001b[39m is not usable in pure-python\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m--> <a href='file:///home/guilhermeleobas/git/rbc/rbc/external.py?line=137'>138</a>\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mNotImplementedError\u001b[39;00m(msg)\n",
       "\u001b[0;31mNotImplementedError\u001b[0m: abs is not usable in pure-python"
      ]
     }
    ],
-   "metadata": {}
+   "source": [
+    "# NBVAL_RAISES_EXCEPTION\n",
+    "abs(-3)"
+   ]
   }
  ],
  "metadata": {
@@ -276,9 +276,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.9"
+   "version": "3.10.2"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
\ No newline at end of file
+}
diff --git a/notebooks/rbc-omnisci-ibis.ipynb b/notebooks/rbc-heavydb-ibis.ipynb
similarity index 85%
rename from notebooks/rbc-omnisci-ibis.ipynb
rename to notebooks/rbc-heavydb-ibis.ipynb
index bcc86e9b..60d4287c 100644
--- a/notebooks/rbc-omnisci-ibis.ipynb
+++ b/notebooks/rbc-heavydb-ibis.ipynb
@@ -16,19 +16,27 @@
    "outputs": [],
    "source": [
     "import ibis\n",
-    "from rbc.omniscidb import RemoteOmnisci"
+    "from rbc.heavydb import RemoteHeavyDB"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "ERROR 1: PROJ: proj_create_from_database: Open of /home/guilhermeleobas/miniconda3/envs/rbc/share/proj failed\n"
+     ]
+    }
+   ],
    "source": [
     "# NBVAL_IGNORE_OUTPUT\n",
-    "omni = RemoteOmnisci()  # RemoteOmisci(user=, password=, host=, port=, dbname=)\n",
-    "omni_ibis = ibis.omniscidb.connect(user=omni.user, password=omni.password,\n",
-    "                              host=omni.host, port=omni.port, database=omni.dbname)"
+    "heavydb = RemoteHeavyDB()  # RemoteHeavyDB(user=, password=, host=, port=, dbname=)\n",
+    "heavydb_ibis = ibis.omniscidb.connect(user=heavydb.user, password=heavydb.password,\n",
+    "                                      host=heavydb.host, port=heavydb.port, database=heavydb.dbname)"
    ]
   },
   {
@@ -142,11 +150,11 @@
    ],
    "source": [
     "# Create test table\n",
-    "omni_ibis.drop_table('mytable')\n",
-    "omni_ibis.create_table('mytable', schema=schema)\n",
-    "mytable = omni_ibis.table('mytable')\n",
+    "heavydb_ibis.drop_table('mytable')\n",
+    "heavydb_ibis.create_table('mytable', schema=schema)\n",
+    "mytable = heavydb_ibis.table('mytable')\n",
     "for i in range(5):\n",
-    "    omni.sql_execute('insert into mytable values (%s, %s, %s, %s)' % (i, i+10, i+100, i+1000))\n",
+    "    heavydb.sql_execute('insert into mytable values (%s, %s, %s, %s)' % (i, i+10, i+100, i+1000))\n",
     "mytable.execute()"
    ]
   },
@@ -157,13 +165,13 @@
    "outputs": [],
    "source": [
     "# Define and register OmnisciDB Runtime UDF\n",
-    "@omni('int32(int32)')\n",
+    "@heavydb('int32(int32)')\n",
     "def incr(x):\n",
     "    return x + 1\n",
-    "@omni('int64(int64)')\n",
+    "@heavydb('int64(int64)')\n",
     "def incr(x):\n",
     "    return x + 10\n",
-    "omni.register()"
+    "heavydb.register()"
    ]
   },
   {
@@ -184,7 +192,7 @@
     }
    ],
    "source": [
-    "t = omni_ibis.sql('select i, incr(i), j, incr(j) from mytable')\n",
+    "t = heavydb_ibis.sql('select i, incr(i), j, incr(j) from mytable')\n",
     "expr = t[t.i < 103]\n",
     "print(expr.compile())"
    ]
@@ -280,7 +288,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.6"
+   "version": "3.10.2"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/rbc-omnisci-simple.ipynb b/notebooks/rbc-heavydb-simple.ipynb
similarity index 74%
rename from notebooks/rbc-omnisci-simple.ipynb
rename to notebooks/rbc-heavydb-simple.ipynb
index 915dcc59..615724ee 100644
--- a/notebooks/rbc-omnisci-simple.ipynb
+++ b/notebooks/rbc-heavydb-simple.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -11,7 +11,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -20,59 +20,59 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from rbc.omniscidb import RemoteOmnisci"
+    "from rbc.heavydb import RemoteHeavyDB"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
     "# NBVAL_IGNORE_OUTPUT\n",
-    "omni = RemoteOmnisci(user='admin', password='HyperInteractive',\n",
-    "                     host='127.0.0.1', port=6274, dbname='omnisci')"
+    "heavydb = RemoteHeavyDB(user='admin', password='HyperInteractive',\n",
+    "                        host='127.0.0.1', port=6274)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
-    "omni.sql_execute('drop table if exists mytable')\n",
-    "omni.sql_execute('create table if not exists mytable (x FLOAT, y DOUBLE, i INT, j BIGINT);');\n",
+    "heavydb.sql_execute('drop table if exists mytable')\n",
+    "heavydb.sql_execute('create table if not exists mytable (x FLOAT, y DOUBLE, i INT, j BIGINT);');\n",
     "data = defaultdict(list)\n",
     "for i in range(5):\n",
     "    data['x'].append(i)\n",
     "    data['y'].append(i)\n",
     "    data['i'].append(i)\n",
     "    data['j'].append(i)\n",
-    "omni.load_table_columnar('mytable', **data)"
+    "heavydb.load_table_columnar('mytable', **data)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Overloading UDFs\n",
-    "@omni('f32(f32)', 'f64(f64)')\n",
+    "@heavydb('f32(f32)', 'f64(f64)')\n",
     "def incr(v):\n",
     "    return v + 1\n",
-    "@omni('i32(i32)', 'i64(i64)')\n",
+    "@heavydb('i32(i32)', 'i64(i64)')\n",
     "def incr(v):\n",
     "    return v + 10"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -85,13 +85,13 @@
        " (5.0, 6.0, 14, 24)]"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "descr, result = omni.sql_execute(\n",
+    "descr, result = heavydb.sql_execute(\n",
     "    'select incr(x), incr(incr(y)), incr(i), incr(incr(j))'\n",
     "    'from mytable')\n",
     "\n",
@@ -115,7 +115,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.6"
+   "version": "3.10.2"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/rbc-omnisci-udf.ipynb b/notebooks/rbc-heavydb-udf.ipynb
similarity index 80%
rename from notebooks/rbc-omnisci-udf.ipynb
rename to notebooks/rbc-heavydb-udf.ipynb
index 6314ff30..43d96447 100644
--- a/notebooks/rbc-omnisci-udf.ipynb
+++ b/notebooks/rbc-heavydb-udf.ipynb
@@ -4,16 +4,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Omnisci Runtime UDF support\n",
+    "# HeavyDB Runtime UDF support\n",
     "\n",
-    "The *Remote Backend Compiler* (RBC) package implements the Omnisci client support for defining so-called Runtime UDFs. That is, while Omnisci server is running, one can register new SQL functions to Omnisci Calcite server as well as provide their implementations in LLVM IR string form. The RBC package supports creating Runtime UDFs from Python functions.\n",
+    "The *Remote Backend Compiler* (RBC) package implements the HeavyDB client support for defining so-called Runtime UDFs. That is, while HeavyDB server is running, one can register new SQL functions to HeavyDB Calcite server as well as provide their implementations in LLVM IR string form. The RBC package supports creating Runtime UDFs from Python functions.\n",
     "\n",
-    "First, we need to connect RBC to Omnisci server:"
+    "First, we need to connect RBC to HeavyDB server:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -22,7 +22,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 9,
    "metadata": {
     "pycharm": {
      "is_executing": false
@@ -31,27 +31,27 @@
    "outputs": [],
    "source": [
     "# NBVAL_IGNORE_OUTPUT\n",
-    "from rbc.omniscidb import RemoteOmnisci\n",
-    "omni = RemoteOmnisci(user='admin', password='HyperInteractive',\n",
-    "                     host='127.0.0.1', port=6274, dbname='omnisci')"
+    "from rbc.heavydb import RemoteHeavyDB\n",
+    "heavydb = RemoteHeavyDB(user='admin', password='HyperInteractive',\n",
+    "                        host='127.0.0.1', port=6274)"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": 10,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "One can use the Runtime UDF functions in SQL queries from several Omnisci clients, for instance, from `pymapd`, `ibis.omniscidb`, or `rbc.omniscidb`. In this demo, we'll use `ibis.omniscidb`. For that, we connect `ibis.omniscidb` to OmnisciDB server as well:"
+    "import ibis\n",
+    "ibis_con = ibis.omniscidb.connect(user=heavydb.user, password=heavydb.password,\n",
+    "                                  host=heavydb.host, port=heavydb.port, database=heavydb.dbname)"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 3,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "import ibis\n",
-    "ibis_con = ibis.omniscidb.connect(user=omni.user, password=omni.password,\n",
-    "                                  host=omni.host, port=omni.port, database=omni.dbname)"
+    "One can use the Runtime UDF functions in SQL queries from several HeavyDB clients, for instance, from `pymapd`, `ibis.omniscidb`, or `rbc.heavydb`. In this demo, we'll use `ibis.omniscidb`. For that, we connect `ibis.omniscidb` to HeavyDB server as well:"
    ]
   },
   {
@@ -63,7 +63,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
@@ -130,16 +130,16 @@
        "4  4.0  4"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "omni.sql_execute('drop table if exists mytable')\n",
-    "omni.sql_execute('create table if not exists mytable (x DOUBLE, i INT);');\n",
+    "heavydb.sql_execute('drop table if exists mytable')\n",
+    "heavydb.sql_execute('create table if not exists mytable (x DOUBLE, i INT);')\n",
     "for _i in range(5):\n",
-    "    omni.sql_execute('insert into mytable values '+str((_i,)*2));\n",
+    "    heavydb.sql_execute(f'insert into mytable values {(_i, _i + 0.0)}')\n",
     "ibis_con.sql('select x, i from mytable').execute()"
    ]
   },
@@ -154,11 +154,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
-    "@omni('f32(f32)', 'f64(f64)')\n",
+    "@heavydb('f32(f32)', 'f64(f64)')\n",
     "def incr(v):\n",
     "    \"\"\"Increment float value by one\"\"\"\n",
     "    return v + 1"
@@ -173,11 +173,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
-    "@omni\n",
+    "@heavydb\n",
     "def incr(v: 'int32') -> 'int32':\n",
     "    \"\"\"Increment integer value by ten\"\"\"\n",
     "    return v + 10"
@@ -187,16 +187,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Finally, we register the defined UDFs to OmnisciDB server:"
+    "Finally, we register the defined UDFs to HeavyDB server:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
-    "omni.register()"
+    "heavydb.register()"
    ]
   },
   {
@@ -208,7 +208,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
@@ -271,7 +271,7 @@
        "2  2.0     3.0  2      12"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -298,7 +298,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.6"
+   "version": "3.10.2"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/rbc-omnisci-udtf-normalize.ipynb b/notebooks/rbc-heavydb-udtf-normalize.ipynb
similarity index 94%
rename from notebooks/rbc-omnisci-udtf-normalize.ipynb
rename to notebooks/rbc-heavydb-udtf-normalize.ipynb
index 8dcb36f3..ca267c0e 100644
--- a/notebooks/rbc-omnisci-udtf-normalize.ipynb
+++ b/notebooks/rbc-heavydb-udtf-normalize.ipynb
@@ -4,23 +4,23 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Example of OmnisciDB UDTF: table column normalization\n",
+    "# Example of HeavyDB UDTF: table column normalization\n",
     "\n",
-    "The aim of this notebook is to demonstrate how to implement with a help of [RBC](https://github.com/xnd-project/rbc/) tool a OmnisciDB User-Defined Table Function (UDTF) in Python that normalizes a table column using the following formula:\n",
+    "The aim of this notebook is to demonstrate how to implement with a help of [RBC](https://github.com/xnd-project/rbc/) tool a HeavyDB User-Defined Table Function (UDTF) in Python that normalizes a table column using the following formula:\n",
     "\n",
     "```\n",
     "  normalize(X) = (X - mean(X)) / std(X)\n",
     "```\n",
     "\n",
     "\n",
-    "## Connecting to OmnisciDB server\n",
+    "## Connecting to HeavyDB server\n",
     "\n",
-    "First, let us establish a connection to the OmnisciDB server using the tools from the RBC project:"
+    "First, let us establish a connection to the HeavyDB server using the tools from the RBC project:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -29,31 +29,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Connecting to OmnisciDB version (5, 6, 0, 'dev-20210111-4d09fe77b2'), cuda=None\n"
+      "Connecting to HeavyDB version (6, 1, 0, 'dev-20220323-6ced1de2b0'), cuda=None\n"
      ]
     }
    ],
    "source": [
     "# NBVAL_IGNORE_OUTPUT\n",
-    "from rbc.omniscidb import RemoteOmnisci\n",
-    "omnisci = RemoteOmnisci(host='127.0.0.1', port=6274)\n",
-    "print(f'Connecting to OmnisciDB version {omnisci.version}, cuda={omnisci.has_cuda}')\n",
-    "assert omnisci.version[:3] >= (5, 4, 0), omnisci.version\n",
-    "assert not omnisci.has_cuda"
+    "from rbc.heavydb import RemoteHeavyDB\n",
+    "heavydb = RemoteHeavyDB(host='127.0.0.1', port=6274)\n",
+    "print(f'Connecting to HeavyDB version {heavydb.version}, cuda={heavydb.has_cuda}')\n",
+    "assert heavydb.version[:3] >= (5, 4, 0), heavydb.version\n",
+    "assert not heavydb.has_cuda"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This notebook requires CUDA-disabled OmnisciDB version 5.4 or newer. If the above fails or one is connected to older version of OmnisciDB, please resolve the issue before continuing."
+    "This notebook requires CUDA-disabled HeavyDB version 5.4 or newer. If the above fails or one is connected to older version of HeavyDB, please resolve the issue before continuing."
    ]
   },
   {
@@ -67,7 +67,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -75,10 +75,10 @@
     "import numpy as np\n",
     "np.random.seed(0)\n",
     "from numpy.random import randn\n",
-    "SQL=lambda query: np.array(list(omnisci.sql_execute(query)[1]))\n",
+    "SQL=lambda query: np.array(list(heavydb.sql_execute(query)[1]))\n",
     "SQL('DROP TABLE IF EXISTS test_data');\n",
     "SQL('CREATE TABLE IF NOT EXISTS test_data (X DOUBLE)')\n",
-    "omnisci.load_table_columnar('test_data', X=np.random.randn(500) * 2 + 10)"
+    "heavydb.load_table_columnar('test_data', X=np.random.randn(500) * 2 + 10)"
    ]
   },
   {
@@ -90,7 +90,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
@@ -102,7 +102,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -128,11 +128,11 @@
     "\n",
     "For very large data sets retrieving the data set to a local system for analysis may be impractical because of network bandwidth or the local system may not have enough RAM to hold the data. In such situations it becomes necessary to implement analyzing tools locally but so that the tools are executed in the server system that holds the data.\n",
     "\n",
-    "OmnisciDB server v 5.4 implements support for users to define UDFs and UDTFs in runtime. UDFs can be applied to table data row-by-row, hence UDFs are data item-wise functions and UDFs return a scalar value. UDTFs, on the other hand, can be applied to table data columns and UDTFs return a table. Hence we call UDTFs also as table functions. \n",
+    "HeavyDB server v 5.4 implements support for users to define UDFs and UDTFs in runtime. UDFs can be applied to table data row-by-row, hence UDFs are data item-wise functions and UDFs return a scalar value. UDTFs, on the other hand, can be applied to table data columns and UDTFs return a table. Hence we call UDTFs also as table functions. \n",
     "\n",
-    "The UDFs and table functions can be defined as Python functions using the [RBC](https://github.com/xnd-project/rbc/) tool that exploits [Numba](https://numba.pydata.org/) to convert Python functions to [LLVM](https://en.wikipedia.org/wiki/LLVM) IR strings and that are registered in the OmnisciDB server as User-Defined SQL functions so that the LLVM IR will be compiled into the SQL queries of the OmnisciDB server.\n",
+    "The UDFs and table functions can be defined as Python functions using the [RBC](https://github.com/xnd-project/rbc/) tool that exploits [Numba](https://numba.pydata.org/) to convert Python functions to [LLVM](https://en.wikipedia.org/wiki/LLVM) IR strings and that are registered in the HeavyDB server as User-Defined SQL functions so that the LLVM IR will be compiled into the SQL queries of the HeavyDB server.\n",
     "\n",
-    "## Analyze data remotely using OmnisciDB user-defined functions\n",
+    "## Analyze data remotely using HeavyDB user-defined functions\n",
     "\n",
     "### Unbiased standard deviation\n",
     "\n",
@@ -141,7 +141,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
@@ -171,20 +171,20 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The `std_welford` takes a sequence `x` as input and returns a `std` as scalar value. To run this function on the data stored in OmnisciDB server, we create an OmnisciDB table function as follows:"
+    "The `std_welford` takes a sequence `x` as input and returns a `std` as scalar value. To run this function on the data stored in HeavyDB server, we create an HeavyDB table function as follows:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
     "import numba\n",
     "numba_std_welford = numba.njit(std_welford)  # register for numba\n",
     "\n",
-    "# register a UDTF as a new SQL function std in OmnisciDB server \n",
-    "@omnisci('int32(Column<double>, int32|sizer=RowMultiplier, OutputColumn<double>)')\n",
+    "# register a UDTF as a new SQL function std in HeavyDB server \n",
+    "@heavydb('int32(Column<double>, int32|sizer=RowMultiplier, OutputColumn<double>)')\n",
     "def unbiased_std(x, m, out):\n",
     "    out[0] = numba_std_welford(x) # store the computed std value in UDTFs output argument\n",
     "    return 1                      # return the size of output column"
@@ -196,7 +196,7 @@
    "source": [
     "Notice that table functions are annotated differently from UDFs. The following applies to all table functions:\n",
     "\n",
-    "- A `omnisci`-decorated function is considered a UDTF when it's signature contains `Column` and `OutputColumn` arguments. Otherwise, the function defines a UDF.\n",
+    "- A `HeavyDB`-decorated function is considered a UDTF when it's signature contains `Column` and `OutputColumn` arguments. Otherwise, the function defines a UDF.\n",
     "\n",
     "- A table function input column arguments must have type `Column<row-type>` where `row-type` is a type specification for column entries. The currently supported row types are `float`, `double`, `int8`, `int16`, `int32`, `int64`, and `bool`. All column input arguments have equal sizes. The input column arguments must be specified in SQL queries via `CURSOR` construction.\n",
     "\n",
@@ -206,14 +206,14 @@
     "\n",
     "- A table function must return the actual size of output column arguments as `int32` value that will be used for reallocating the memory of output column arguments. Table functions are called in SQL queries using `TABLE` construction.\n",
     "\n",
-    "For example, the table function `unbiased_std` takes three arguments: `x` is input column argument, `m` is sizer argument, and `out` is output column argument. For the sizes of column arguments, `len(out) == m * len(x)` holds. The table function returns `1` that indicates to OmnisciDB query engine that the size of output column `out` is equal to `1` and the engine will reallocate the `out` memory accordingly.\n",
+    "For example, the table function `unbiased_std` takes three arguments: `x` is input column argument, `m` is sizer argument, and `out` is output column argument. For the sizes of column arguments, `len(out) == m * len(x)` holds. The table function returns `1` that indicates to HeavyDB query engine that the size of output column `out` is equal to `1` and the engine will reallocate the `out` memory accordingly.\n",
     "\n",
     "Now let's compute the standard deviation in the server:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
@@ -222,7 +222,7 @@
        "array([[1.99831287]])"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -248,18 +248,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
-    "@omnisci('double(double, double, double)')\n",
+    "@heavydb('double(double, double, double)')\n",
     "def normalize_udf(x, mean, std):\n",
     "    return (x - mean)/std"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
@@ -286,11 +286,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [],
    "source": [
-    "@omnisci('int32(Column<double>, int32|sizer=RowMultiplier, OutputColumn<double>)')\n",
+    "@heavydb('int32(Column<double>, int32|sizer=RowMultiplier, OutputColumn<double>)')\n",
     "def normalize_udtf(x, m, out):\n",
     "    A = 0.0                         # running mean value\n",
     "    Q = 0.0\n",
@@ -307,7 +307,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
@@ -336,13 +336,13 @@
    "source": [
     "### Final notes\n",
     "\n",
-    "- Table functions currently work only on CUDA-disabled OmnisciDB server.\n",
+    "- Table functions currently work only on CUDA-disabled HeavyDB server.\n",
     "- SQL aggregate functions and likely other operations do not work on table functions, for example:\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -361,7 +361,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
@@ -370,7 +370,7 @@
        "array([[3.38841455e-15]])"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 26,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -399,7 +399,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.6"
+   "version": "3.8.12"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/rbc-intro.ipynb b/notebooks/rbc-intro.ipynb
index 0261ba63..26ade389 100644
--- a/notebooks/rbc-intro.ipynb
+++ b/notebooks/rbc-intro.ipynb
@@ -32,10 +32,10 @@
     "\n",
     "- *Remote Backend Compiler - RBC*: https://github.com/xnd-project/rbc\n",
     "- A Python-to-Python prototype uses Numba for LLVM IR generation and Numba llvmlite for machine code compilation\n",
-    "- A Python-to-SQL application uses Numba for LLVM IR generation and OmniSciDB for machine code compilation\n",
-    "  * OmniSciDB is a GPU enabled SQL database server\n",
-    "  * OmniSciDB uses LLVM Compiler C++ library for JIT compilation\n",
-    "  * https://www.omnisci.com/\n",
+    "- A Python-to-SQL application uses Numba for LLVM IR generation and HeavyDB for machine code compilation\n",
+    "  * HeavyDB is a GPU enabled SQL database server\n",
+    "  * HeavyDB uses LLVM Compiler C++ library for JIT compilation\n",
+    "  * https://www.heavy.ai/\n",
     "\n",
     "# Demo of the prototype below"
    ]
diff --git a/notebooks/rbc-omnisci-array.ipynb b/notebooks/rbc-omnisci-array.ipynb
deleted file mode 100644
index 907f023f..00000000
--- a/notebooks/rbc-omnisci-array.ipynb
+++ /dev/null
@@ -1,267 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import warnings; warnings.filterwarnings('ignore')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from rbc.omniscidb import RemoteOmnisci"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# NBVAL_IGNORE_OUTPUT\n",
-    "omnisci = RemoteOmnisci(user='admin', password='HyperInteractive',\n",
-    "                     host='127.0.0.1', port=6274, dbname='omnisci')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "SQL=lambda query: np.array(list(omnisci.sql_execute(query)[1]), dtype=object)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[array([1, 2, 3, 1], dtype=object)]"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "SQL('DROP TABLE IF EXISTS mytable')\n",
-    "SQL('CREATE TABLE IF NOT EXISTS mytable (i INT[]);');\n",
-    "for i in range(5):\n",
-    "    SQL('INSERT INTO mytable VALUES (ARRAY[1,2,3,'+str(i)+'])');\n",
-    "list(SQL('SELECT * FROM mytable')[1])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@omnisci('i32(i32[])')\n",
-    "def sum_i32(x):\n",
-    "    s = 0\n",
-    "    for i in range(len(x)):\n",
-    "        s += x[i]\n",
-    "    return s"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[list([1, 2, 3, 0]), 6],\n",
-       "       [list([1, 2, 3, 1]), 7],\n",
-       "       [list([1, 2, 3, 2]), 8],\n",
-       "       [list([1, 2, 3, 3]), 9],\n",
-       "       [list([1, 2, 3, 4]), 10]], dtype=object)"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "SQL('SELECT i, sum_i32(i) FROM mytable')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "--------------------------------------cpu---------------------------------------\n",
-      "; ModuleID = 'rbc.irtools.compile_to_IR'\n",
-      "source_filename = \"<string>\"\n",
-      "target triple = \"x86_64-unknown-linux-gnu\"\n",
-      "\n",
-      "@\"_ZN08NumbaEnv8__main__11sum_i32$244E22$28STRUCT__iPLbK$29$2a\" = common local_unnamed_addr global i8* null\n",
-      "@\"_ZN08NumbaEnv3rbc15omnisci_backend14omnisci_buffer18omnisci_buffer_len12$3clocals$3e16$3clambda$3e$245E22$28STRUCT__iPLbK$29$2a\" = common local_unnamed_addr global i8* null\n",
-      "@\"_ZN08NumbaEnv3rbc15omnisci_backend14omnisci_buffer22omnisci_buffer_getitem12$3clocals$3e16$3clambda$3e$246E22$28STRUCT__iPLbK$29$2ax\" = common local_unnamed_addr global i8* null\n",
-      "\n",
-      "; Function Attrs: norecurse nounwind readonly\n",
-      "define i32 @sum_i32_ia_V16VOmnisciArrayTyperiRA({ i32*, i64, i8 }* nocapture readonly %.1) local_unnamed_addr #0 {\n",
-      "entry:\n",
-      "  %.17.i.i = getelementptr { i32*, i64, i8 }, { i32*, i64, i8 }* %.1, i64 0, i32 1\n",
-      "  %.18.i.i = load i64, i64* %.17.i.i, align 8, !noalias !0\n",
-      "  %.107.i.inv = icmp sgt i64 %.18.i.i, 0\n",
-      "  br i1 %.107.i.inv, label %B20.i.lr.ph, label %\"_ZN8__main__11sum_i32$244E22$28STRUCT__iPLbK$29$2a.exit\"\n",
-      "\n",
-      "B20.i.lr.ph:                                      ; preds = %entry\n",
-      "  %.221.i.i = getelementptr { i32*, i64, i8 }, { i32*, i64, i8 }* %.1, i64 0, i32 0\n",
-      "  %.23.i.i = load i32*, i32** %.221.i.i, align 8, !noalias !5\n",
-      "  %min.iters.check = icmp ult i64 %.18.i.i, 16\n",
-      "  br i1 %min.iters.check, label %B20.i.preheader, label %vector.ph\n",
-      "\n",
-      "vector.ph:                                        ; preds = %B20.i.lr.ph\n",
-      "  %n.vec = and i64 %.18.i.i, -16\n",
-      "  br label %vector.body\n",
-      "\n",
-      "vector.body:                                      ; preds = %vector.body, %vector.ph\n",
-      "  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]\n",
-      "  %vec.phi = phi <4 x i64> [ zeroinitializer, %vector.ph ], [ %12, %vector.body ]\n",
-      "  %vec.phi5 = phi <4 x i64> [ zeroinitializer, %vector.ph ], [ %13, %vector.body ]\n",
-      "  %vec.phi6 = phi <4 x i64> [ zeroinitializer, %vector.ph ], [ %14, %vector.body ]\n",
-      "  %vec.phi7 = phi <4 x i64> [ zeroinitializer, %vector.ph ], [ %15, %vector.body ]\n",
-      "  %0 = getelementptr i32, i32* %.23.i.i, i64 %index\n",
-      "  %1 = bitcast i32* %0 to <4 x i32>*\n",
-      "  %wide.load = load <4 x i32>, <4 x i32>* %1, align 4, !noalias !5\n",
-      "  %2 = getelementptr i32, i32* %0, i64 4\n",
-      "  %3 = bitcast i32* %2 to <4 x i32>*\n",
-      "  %wide.load17 = load <4 x i32>, <4 x i32>* %3, align 4, !noalias !5\n",
-      "  %4 = getelementptr i32, i32* %0, i64 8\n",
-      "  %5 = bitcast i32* %4 to <4 x i32>*\n",
-      "  %wide.load18 = load <4 x i32>, <4 x i32>* %5, align 4, !noalias !5\n",
-      "  %6 = getelementptr i32, i32* %0, i64 12\n",
-      "  %7 = bitcast i32* %6 to <4 x i32>*\n",
-      "  %wide.load19 = load <4 x i32>, <4 x i32>* %7, align 4, !noalias !5\n",
-      "  %8 = sext <4 x i32> %wide.load to <4 x i64>\n",
-      "  %9 = sext <4 x i32> %wide.load17 to <4 x i64>\n",
-      "  %10 = sext <4 x i32> %wide.load18 to <4 x i64>\n",
-      "  %11 = sext <4 x i32> %wide.load19 to <4 x i64>\n",
-      "  %12 = add <4 x i64> %vec.phi, %8\n",
-      "  %13 = add <4 x i64> %vec.phi5, %9\n",
-      "  %14 = add <4 x i64> %vec.phi6, %10\n",
-      "  %15 = add <4 x i64> %vec.phi7, %11\n",
-      "  %index.next = add i64 %index, 16\n",
-      "  %16 = icmp eq i64 %index.next, %n.vec\n",
-      "  br i1 %16, label %middle.block, label %vector.body, !llvm.loop !8\n",
-      "\n",
-      "middle.block:                                     ; preds = %vector.body\n",
-      "  %ind.end = sub nsw i64 %.18.i.i, %n.vec\n",
-      "  %bin.rdx = add <4 x i64> %13, %12\n",
-      "  %bin.rdx20 = add <4 x i64> %bin.rdx, %14\n",
-      "  %bin.rdx21 = add <4 x i64> %bin.rdx20, %15\n",
-      "  %rdx.shuf = shufflevector <4 x i64> %bin.rdx21, <4 x i64> undef, <4 x i32> <i32 2, i32 3, i32 undef, i32 undef>\n",
-      "  %bin.rdx22 = add <4 x i64> %rdx.shuf, %bin.rdx21\n",
-      "  %rdx.shuf23 = shufflevector <4 x i64> %bin.rdx22, <4 x i64> undef, <4 x i32> <i32 1, i32 undef, i32 undef, i32 undef>\n",
-      "  %bin.rdx24 = add <4 x i64> %rdx.shuf23, %bin.rdx22\n",
-      "  %17 = extractelement <4 x i64> %bin.rdx24, i32 0\n",
-      "  %cmp.n = icmp eq i64 %.18.i.i, %n.vec\n",
-      "  br i1 %cmp.n, label %\"_ZN8__main__11sum_i32$244E22$28STRUCT__iPLbK$29$2a.exit.loopexit\", label %B20.i.preheader\n",
-      "\n",
-      "B20.i.preheader:                                  ; preds = %middle.block, %B20.i.lr.ph\n",
-      "  %s.2.0.i3.ph = phi i64 [ %17, %middle.block ], [ 0, %B20.i.lr.ph ]\n",
-      "  %.93.i.02.ph = phi i64 [ %n.vec, %middle.block ], [ 0, %B20.i.lr.ph ]\n",
-      "  %.96.i.01.ph = phi i64 [ %ind.end, %middle.block ], [ %.18.i.i, %B20.i.lr.ph ]\n",
-      "  br label %B20.i\n",
-      "\n",
-      "B20.i:                                            ; preds = %B20.i.preheader, %B20.i\n",
-      "  %s.2.0.i3 = phi i64 [ %.251.i, %B20.i ], [ %s.2.0.i3.ph, %B20.i.preheader ]\n",
-      "  %.93.i.02 = phi i64 [ %.170.i, %B20.i ], [ %.93.i.02.ph, %B20.i.preheader ]\n",
-      "  %.96.i.01 = phi i64 [ %.166.i, %B20.i ], [ %.96.i.01.ph, %B20.i.preheader ]\n",
-      "  %.170.i = add nuw nsw i64 %.93.i.02, 1\n",
-      "  %.166.i = add nsw i64 %.96.i.01, -1\n",
-      "  %.24.i.i = getelementptr i32, i32* %.23.i.i, i64 %.93.i.02\n",
-      "  %.25.i.i = load i32, i32* %.24.i.i, align 4, !noalias !5\n",
-      "  %.250.i = sext i32 %.25.i.i to i64\n",
-      "  %.251.i = add nsw i64 %s.2.0.i3, %.250.i\n",
-      "  %.157.i = icmp sgt i64 %.96.i.01, 1\n",
-      "  br i1 %.157.i, label %B20.i, label %\"_ZN8__main__11sum_i32$244E22$28STRUCT__iPLbK$29$2a.exit.loopexit\", !llvm.loop !10\n",
-      "\n",
-      "\"_ZN8__main__11sum_i32$244E22$28STRUCT__iPLbK$29$2a.exit.loopexit\": ; preds = %B20.i, %middle.block\n",
-      "  %.251.i.lcssa = phi i64 [ %17, %middle.block ], [ %.251.i, %B20.i ]\n",
-      "  %phitmp = trunc i64 %.251.i.lcssa to i32\n",
-      "  br label %\"_ZN8__main__11sum_i32$244E22$28STRUCT__iPLbK$29$2a.exit\"\n",
-      "\n",
-      "\"_ZN8__main__11sum_i32$244E22$28STRUCT__iPLbK$29$2a.exit\": ; preds = %\"_ZN8__main__11sum_i32$244E22$28STRUCT__iPLbK$29$2a.exit.loopexit\", %entry\n",
-      "  %s.2.0.i.lcssa = phi i32 [ 0, %entry ], [ %phitmp, %\"_ZN8__main__11sum_i32$244E22$28STRUCT__iPLbK$29$2a.exit.loopexit\" ]\n",
-      "  ret i32 %s.2.0.i.lcssa\n",
-      "}\n",
-      "\n",
-      "attributes #0 = { norecurse nounwind readonly }\n",
-      "\n",
-      "!0 = !{!1, !3}\n",
-      "!1 = distinct !{!1, !2, !\"_ZN3rbc15omnisci_backend14omnisci_buffer18omnisci_buffer_len12$3clocals$3e16$3clambda$3e$245E22$28STRUCT__iPLbK$29$2a: %retptr\"}\n",
-      "!2 = distinct !{!2, !\"_ZN3rbc15omnisci_backend14omnisci_buffer18omnisci_buffer_len12$3clocals$3e16$3clambda$3e$245E22$28STRUCT__iPLbK$29$2a\"}\n",
-      "!3 = distinct !{!3, !4, !\"_ZN8__main__11sum_i32$244E22$28STRUCT__iPLbK$29$2a: %retptr\"}\n",
-      "!4 = distinct !{!4, !\"_ZN8__main__11sum_i32$244E22$28STRUCT__iPLbK$29$2a\"}\n",
-      "!5 = !{!6, !3}\n",
-      "!6 = distinct !{!6, !7, !\"_ZN3rbc15omnisci_backend14omnisci_buffer22omnisci_buffer_getitem12$3clocals$3e16$3clambda$3e$246E22$28STRUCT__iPLbK$29$2ax: %retptr\"}\n",
-      "!7 = distinct !{!7, !\"_ZN3rbc15omnisci_backend14omnisci_buffer22omnisci_buffer_getitem12$3clocals$3e16$3clambda$3e$246E22$28STRUCT__iPLbK$29$2ax\"}\n",
-      "!8 = distinct !{!8, !9}\n",
-      "!9 = !{!\"llvm.loop.isvectorized\", i32 1}\n",
-      "!10 = distinct !{!10, !11, !9}\n",
-      "!11 = !{!\"llvm.loop.unroll.runtime.disable\"}\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n"
-     ]
-    }
-   ],
-   "source": [
-    "# NBVAL_IGNORE_OUTPUT\n",
-    "print(sum_i32)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/rbc/errors.py b/rbc/errors.py
index c56a8f96..9b91b3fb 100644
--- a/rbc/errors.py
+++ b/rbc/errors.py
@@ -7,9 +7,9 @@
 from numba.core.errors import TypingError
 
 
-class OmnisciServerError(Exception):
+class HeavyDBServerError(Exception):
     """
-    Raised when OmnisciDB server raises a runtime error that RBC knows
+    Raised when HeavyDB server raises a runtime error that RBC knows
     how to interpret.
     """
     pass
diff --git a/rbc/externals/heavydb.py b/rbc/externals/heavydb.py
index e4e29036..959f77bd 100644
--- a/rbc/externals/heavydb.py
+++ b/rbc/externals/heavydb.py
@@ -1,4 +1,4 @@
-"""External functions defined by the OmniSciDB server
+"""External functions defined by the HeavyDB server
 """
 
 from rbc import irutils
@@ -15,7 +15,7 @@ def set_output_row_size(typingctx, set_output_row_size):
     allocates the corresponding column buffers
 
     .. note::
-        ``set_output_row_size`` is available only for CPU target and OmniSciDB v5.7 or newer
+        ``set_output_row_size`` is available only for CPU target and HeavyDB v5.7 or newer
     """
     # void is declared as 'none' in Numba and 'none' is converted to a void* (int8*). See:
     # https://github.com/numba/numba/blob/6881dfe3883d1344014ea16185ed87de4b75b9a1/numba/core/types/__init__.py#L95
@@ -24,7 +24,7 @@ def set_output_row_size(typingctx, set_output_row_size):
     def codegen(context, builder, sig, args):
         target_info = TargetInfo()
         if target_info.software[1][:3] < (5, 7, 0):
-            msg = 'set_output_row_size is only available in OmniSciDB 5.7 or newer'
+            msg = 'set_output_row_size is only available in HeavyDB 5.7 or newer'
             raise UnsupportedError(msg)
 
         fnty = ir.FunctionType(ir.VoidType(), [ir.IntType(64)])
diff --git a/rbc/heavyai/array.py b/rbc/heavyai/array.py
index 2bbbbffd..52086a0a 100644
--- a/rbc/heavyai/array.py
+++ b/rbc/heavyai/array.py
@@ -1,12 +1,12 @@
-"""Implement Omnisci Array type support
+"""Implement HeavyDB Array type support
 """
 
-__all__ = ['ArrayPointer', 'Array', 'OmnisciArrayType']
+__all__ = ['ArrayPointer', 'Array', 'HeavyDBArrayType']
 
 from rbc import typesystem, errors
 from .buffer import (BufferPointer, Buffer,
-                     OmnisciBufferType,
-                     omnisci_buffer_constructor)
+                     HeavyDBBufferType,
+                     heavydb_buffer_constructor)
 from numba.core import extending, types
 from typing import Union, TypeVar
 
@@ -14,10 +14,10 @@
 T = TypeVar('T')
 
 
-class OmnisciArrayType(OmnisciBufferType):
-    """Omnisci Array type for RBC typesystem.
+class HeavyDBArrayType(HeavyDBBufferType):
+    """HeavyDB Array type for RBC typesystem.
 
-    :code:`Omnisci Array<T>` is defined as follows (using C++ syntax)::
+    :code:`HeavyDB Array<T>` is defined as follows (using C++ syntax)::
 
       template<typename T>
       struct Array {
@@ -54,9 +54,9 @@ class Array(Buffer):
     .. code-block:: python
 
         from numba import types
-        from rbc.omnisci_backend import Array
+        from rbc.heavydb import Array
 
-        @omnisci('int64[](int64)')
+        @heavydb('int64[](int64)')
         def my_arange(size):
             arr = Array(size, types.int64)
             for i in range(size):
@@ -134,12 +134,12 @@ def T(self):
 
 @extending.lower_builtin(Array, types.Integer, types.StringLiteral)
 @extending.lower_builtin(Array, types.Integer, types.NumberClass)
-def omnisci_array_constructor(context, builder, sig, args):
-    return omnisci_buffer_constructor(context, builder, sig, args)
+def heavydb_array_constructor(context, builder, sig, args):
+    return heavydb_buffer_constructor(context, builder, sig, args)
 
 
 @extending.type_callable(Array)
-def type_omnisci_array(context):
+def type_heavydb_array(context):
     def typer(size, dtype):
         if isinstance(dtype, types.StringLiteral):
             element_type = typesystem.Type.fromstring(dtype.literal_value)
@@ -147,5 +147,5 @@ def typer(size, dtype):
             element_type = typesystem.Type.fromobject(dtype)
         else:
             raise errors.NumbaNotImplementedError(repr(dtype))
-        return OmnisciArrayType((element_type,)).tonumba()
+        return HeavyDBArrayType((element_type,)).tonumba()
     return typer
diff --git a/rbc/heavyai/buffer.py b/rbc/heavyai/buffer.py
index 6f992552..8da43ad1 100644
--- a/rbc/heavyai/buffer.py
+++ b/rbc/heavyai/buffer.py
@@ -1,6 +1,6 @@
-"""Implement Buffer type as a base class to Omnisci Array and Column types.
+"""Implement Buffer type as a base class to HeavyDB Array and Column types.
 
-Omnisci Buffer represents the following structure:
+HeavyDB Buffer represents the following structure:
 
   template<typename T>
   struct Buffer {
@@ -19,12 +19,12 @@
   __setitem__
 
 to provide a minimal functionality for accessing and manipulating the
-Omnisci buffer objects from UDF/UDTFs.
+HeavyDB buffer objects from UDF/UDTFs.
 """
 
 
 import operator
-from .metatype import OmnisciMetaType
+from .metatype import HeavyDBMetaType
 from llvmlite import ir
 import numpy as np
 from rbc import typesystem, irutils
@@ -39,8 +39,8 @@
 fp64 = ir.DoubleType()
 
 
-class OmnisciBufferType(typesystem.Type):
-    """Typesystem type class for Omnisci buffer structures.
+class HeavyDBBufferType(typesystem.Type):
+    """Typesystem type class for HeavyDB buffer structures.
     """
     # When True, buffer type arguments are passed by value to
     # functions [not recommended].
@@ -83,7 +83,7 @@ def tonumba(self, bool_is_int8=None):
 
 
 class BufferType(types.Type):
-    """Numba type class for Omnisci buffer structures.
+    """Numba type class for HeavyDB buffer structures.
     """
 
     @property
@@ -95,7 +95,7 @@ def eltype(self):
 
 
 class BufferPointer(types.IterableType):
-    """Numba type class for pointers to Omnisci buffer structures.
+    """Numba type class for pointers to HeavyDB buffer structures.
 
     We are not deriving from CPointer because BufferPointer getitem is
     used to access the data stored in Buffer ptr member.
@@ -134,18 +134,18 @@ def __init__(self, dmm, fe_type):
         super(BufferPointerIteratorModel, self).__init__(dmm, fe_type, members)
 
 
-class BufferMeta(OmnisciMetaType):
+class BufferMeta(HeavyDBMetaType):
     pass
 
 
 class Buffer(object, metaclass=BufferMeta):
-    """Represents Omnisci Buffer that can be constructed within UDF/UDTFs.
+    """Represents HeavyDB Buffer that can be constructed within UDF/UDTFs.
     """
 
 
 @datamodel.register_default(BufferPointer)
 class BufferPointerModel(datamodel.models.PointerModel):
-    """Base class for Omnisci buffer pointer models.
+    """Base class for HeavyDB buffer pointer models.
 
     Subclasses should register the model for the corresponding
     BufferPointer subclass, for instance::
@@ -156,14 +156,14 @@ class ArrayPointerModel(BufferPointerModel):
     """
 
 
-def omnisci_buffer_constructor(context, builder, sig, args):
+def heavydb_buffer_constructor(context, builder, sig, args):
     """
 
     Usage:
 
-      extending.lower_builtin(MyBuffer, numba.types.Integer, ...)(omnisci_buffer_constructor)
+      extending.lower_builtin(MyBuffer, numba.types.Integer, ...)(heavydb_buffer_constructor)
 
-    will enable creating MyBuffer instance from a Omnisci UDF/UDTF definition:
+    will enable creating MyBuffer instance from a HeavyDB UDF/UDTF definition:
 
       b = MyBuffer(<size>, ...)
 
@@ -201,7 +201,7 @@ def omnisci_buffer_constructor(context, builder, sig, args):
 
 
 @extending.intrinsic
-def omnisci_buffer_ptr_get_ptr_(typingctx, data):
+def heavydb_buffer_ptr_get_ptr_(typingctx, data):
     eltype = data.eltype
     ptrtype = types.CPointer(eltype)
     sig = ptrtype(data)
@@ -217,7 +217,7 @@ def codegen(context, builder, signature, args):
 
 
 @extending.intrinsic
-def omnisci_buffer_get_ptr_(typingctx, data):
+def heavydb_buffer_get_ptr_(typingctx, data):
     eltype = data.eltype
     ptrtype = types.CPointer(eltype)
     sig = ptrtype(data)
@@ -232,7 +232,7 @@ def codegen(context, builder, signature, args):
 
 
 @extending.intrinsic
-def omnisci_buffer_ptr_item_get_ptr_(typingctx, data, index):
+def heavydb_buffer_ptr_item_get_ptr_(typingctx, data, index):
     eltype = data.eltype
     ptrtype = types.CPointer(eltype)
     sig = ptrtype(data, index)
@@ -248,26 +248,26 @@ def codegen(context, builder, signature, args):
 
 
 @extending.overload_method(BufferPointer, 'ptr')
-def omnisci_buffer_get_ptr(x, index=None):
+def heavydb_buffer_get_ptr(x, index=None):
     if isinstance(x, BufferPointer):
         if cgutils.is_nonelike(index):
             def impl(x, index=None):
-                return omnisci_buffer_ptr_get_ptr_(x)
+                return heavydb_buffer_ptr_get_ptr_(x)
         else:
             def impl(x, index=None):
-                return omnisci_buffer_ptr_item_get_ptr_(x, index)
+                return heavydb_buffer_ptr_item_get_ptr_(x, index)
         return impl
     if isinstance(x, BufferType):
         if cgutils.is_nonelike(index):
             def impl(x, index=None):
-                return omnisci_buffer_get_ptr_(x)
+                return heavydb_buffer_get_ptr_(x)
         else:
-            raise NotImplementedError(f'omnisci_buffer_item_get_ptr_({x}, {index})')
+            raise NotImplementedError(f'heavydb_buffer_item_get_ptr_({x}, {index})')
         return impl
 
 
 @extending.intrinsic
-def omnisci_buffer_ptr_len_(typingctx, data):
+def heavydb_buffer_ptr_len_(typingctx, data):
     sig = types.int64(data)
 
     def codegen(context, builder, signature, args):
@@ -281,7 +281,7 @@ def codegen(context, builder, signature, args):
 
 
 @extending.intrinsic
-def omnisci_buffer_len_(typingctx, data):
+def heavydb_buffer_len_(typingctx, data):
     sig = types.int64(data)
 
     def codegen(context, builder, signature, args):
@@ -292,15 +292,15 @@ def codegen(context, builder, signature, args):
 
 
 @extending.overload(len)
-def omnisci_buffer_len(x):
+def heavydb_buffer_len(x):
     if isinstance(x, BufferPointer):
-        return lambda x: omnisci_buffer_ptr_len_(x)
+        return lambda x: heavydb_buffer_ptr_len_(x)
     if isinstance(x, BufferType):
-        return lambda x: omnisci_buffer_len_(x)
+        return lambda x: heavydb_buffer_len_(x)
 
 
 @extending.intrinsic
-def omnisci_buffer_ptr_getitem_(typingctx, data, index):
+def heavydb_buffer_ptr_getitem_(typingctx, data, index):
     sig = data.eltype(data, index)
 
     def codegen(context, builder, signature, args):
@@ -316,7 +316,7 @@ def codegen(context, builder, signature, args):
 
 
 @extending.intrinsic
-def omnisci_buffer_getitem_(typingctx, data, index):
+def heavydb_buffer_getitem_(typingctx, data, index):
     eltype = data.eltype
     sig = eltype(data, index)
 
@@ -330,11 +330,11 @@ def codegen(context, builder, signature, args):
 
 
 @extending.overload(operator.getitem)
-def omnisci_buffer_getitem(x, i):
+def heavydb_buffer_getitem(x, i):
     if isinstance(x, BufferPointer):
-        return lambda x, i: omnisci_buffer_ptr_getitem_(x, i)
+        return lambda x, i: heavydb_buffer_ptr_getitem_(x, i)
     if isinstance(x, BufferType):
-        return lambda x, i: omnisci_buffer_getitem_(x, i)
+        return lambda x, i: heavydb_buffer_getitem_(x, i)
 
 
 # [rbc issue-197] Numba promotes operations like
@@ -364,7 +364,7 @@ def truncate_or_extend(builder, nb_value, eltype, value, buf_typ):
 
 
 @extending.intrinsic
-def omnisci_buffer_ptr_setitem_(typingctx, data, index, value):
+def heavydb_buffer_ptr_setitem_(typingctx, data, index, value):
     sig = types.none(data, index, value)
 
     eltype = data.eltype
@@ -386,7 +386,7 @@ def codegen(context, builder, signature, args):
 
 
 @extending.intrinsic
-def omnisci_buffer_setitem_(typingctx, data, index, value):
+def heavydb_buffer_setitem_(typingctx, data, index, value):
     sig = types.none(data, index, value)
 
     eltype = data.members[0].dtype
@@ -403,15 +403,15 @@ def codegen(context, builder, signature, args):
 
 
 @extending.overload(operator.setitem)
-def omnisci_buffer_setitem(a, i, v):
+def heavydb_buffer_setitem(a, i, v):
     if isinstance(a, BufferPointer):
-        return lambda a, i, v: omnisci_buffer_ptr_setitem_(a, i, v)
+        return lambda a, i, v: heavydb_buffer_ptr_setitem_(a, i, v)
     if isinstance(a, BufferType):
-        return lambda a, i, v: omnisci_buffer_setitem_(a, i, v)
+        return lambda a, i, v: heavydb_buffer_setitem_(a, i, v)
 
 
 @extending.intrinsic
-def omnisci_buffer_is_null_(typingctx, data):
+def heavydb_buffer_is_null_(typingctx, data):
     sig = types.int8(data)
 
     def codegen(context, builder, sig, args):
@@ -423,7 +423,7 @@ def codegen(context, builder, sig, args):
 
 
 @extending.intrinsic
-def omnisci_buffer_set_null_(typingctx, data):
+def heavydb_buffer_set_null_(typingctx, data):
     sig = types.none(data)
 
     def codegen(context, builder, sig, args):
@@ -435,7 +435,7 @@ def codegen(context, builder, sig, args):
 
 
 @extending.intrinsic
-def omnisci_buffer_idx_is_null_(typingctx, col_var, row_idx):
+def heavydb_buffer_idx_is_null_(typingctx, col_var, row_idx):
     T = col_var.eltype
     sig = types.boolean(col_var, row_idx)
 
@@ -462,19 +462,19 @@ def codegen(context, builder, signature, args):
 # as opposed to "BufferType.is_null" that checks if an index in a
 # column is null
 @extending.overload_method(BufferPointer, 'is_null')
-def omnisci_buffer_is_null(x, row_idx=None):
+def heavydb_buffer_is_null(x, row_idx=None):
     if isinstance(x, BufferPointer):
         if cgutils.is_nonelike(row_idx):
             def impl(x, row_idx=None):
-                return omnisci_buffer_is_null_(x)
+                return heavydb_buffer_is_null_(x)
         else:
             def impl(x, row_idx=None):
-                return omnisci_buffer_idx_is_null_(x, row_idx)
+                return heavydb_buffer_idx_is_null_(x, row_idx)
         return impl
 
 
 @extending.intrinsic
-def omnisci_buffer_idx_set_null(typingctx, arr, row_idx):
+def heavydb_buffer_idx_set_null(typingctx, arr, row_idx):
     T = arr.eltype
     sig = types.none(arr, row_idx)
 
@@ -488,7 +488,7 @@ def omnisci_buffer_idx_set_null(typingctx, arr, row_idx):
 
     def codegen(context, builder, signature, args):
         # get the operator.setitem intrinsic
-        fnop = context.typing_context.resolve_value_type(omnisci_buffer_ptr_setitem_)
+        fnop = context.typing_context.resolve_value_type(heavydb_buffer_ptr_setitem_)
         setitem_sig = types.none(arr, row_idx, T)
         # register the intrinsic in the typing ctx
         fnop.get_call_type(context.typing_context, setitem_sig.args, {})
@@ -506,14 +506,14 @@ def codegen(context, builder, signature, args):
 
 
 @extending.overload_method(BufferPointer, 'set_null')
-def omnisci_buffer_set_null(x, row_idx=None):
+def heavydb_buffer_set_null(x, row_idx=None):
     if isinstance(x, BufferPointer):
         if cgutils.is_nonelike(row_idx):
             def impl(x, row_idx=None):
-                return omnisci_buffer_set_null_(x)
+                return heavydb_buffer_set_null_(x)
         else:
             def impl(x, row_idx=None):
-                return omnisci_buffer_idx_set_null(x, row_idx)
+                return heavydb_buffer_idx_set_null(x, row_idx)
             return impl
         return impl
 
@@ -529,7 +529,7 @@ def impl(a, b):
 
 
 @extending.overload_attribute(BufferPointer, 'dtype')
-def omnisci_buffer_dtype(x):
+def heavydb_buffer_dtype(x):
     if isinstance(x, BufferPointer):
         dtype = x.eltype
 
diff --git a/rbc/heavyai/bytes.py b/rbc/heavyai/bytes.py
index d5758522..b4dcbfbf 100644
--- a/rbc/heavyai/bytes.py
+++ b/rbc/heavyai/bytes.py
@@ -1,6 +1,6 @@
-'''Omnisci Bytes type that corresponds to Omnisci type TEXT ENCODED NONE.
+'''HeavyDB Bytes type that corresponds to HeavyDB type TEXT ENCODED NONE.
 
-Omnisci Bytes represents the following structure:
+HeavyDB Bytes represents the following structure:
 
   struct Bytes {
     char* ptr;
@@ -8,17 +8,17 @@
   }
 '''
 
-__all__ = ['BytesPointer', 'Bytes', 'OmnisciBytesType']
+__all__ = ['BytesPointer', 'Bytes', 'HeavyDBBytesType']
 
 from rbc import typesystem
 from .buffer import (
-    BufferPointer, Buffer, OmnisciBufferType,
-    omnisci_buffer_constructor)
+    BufferPointer, Buffer, HeavyDBBufferType,
+    heavydb_buffer_constructor)
 from numba.core import types, extending
 
 
-class OmnisciBytesType(OmnisciBufferType):
-    """Omnisci Bytes type for RBC typesystem.
+class HeavyDBBytesType(HeavyDBBufferType):
+    """HeavyDB Bytes type for RBC typesystem.
     """
 
     @property
@@ -42,12 +42,12 @@ class Bytes(Buffer):
 
 
 @extending.lower_builtin(Bytes, types.Integer)
-def omnisci_bytes_constructor(context, builder, sig, args):
-    return omnisci_buffer_constructor(context, builder, sig, args)
+def heavydb_bytes_constructor(context, builder, sig, args):
+    return heavydb_buffer_constructor(context, builder, sig, args)
 
 
 @extending.type_callable(Bytes)
-def type_omnisci_bytes(context):
+def type_heavydb_bytes(context):
     def typer(size):
         return typesystem.Type.fromobject('Bytes').tonumba()
     return typer
diff --git a/rbc/heavyai/column.py b/rbc/heavyai/column.py
index f3fc7677..85e5b0b4 100644
--- a/rbc/heavyai/column.py
+++ b/rbc/heavyai/column.py
@@ -1,16 +1,16 @@
-"""Implement Omnisci Column type support
+"""Implement Heavydb Column type support
 
-Omnisci Column type is the type of input/output column arguments in
+Heavydb Column type is the type of input/output column arguments in
 UDTFs.
 """
 
-__all__ = ['OutputColumn', 'Column', 'OmnisciOutputColumnType', 'OmnisciColumnType',
-           'OmnisciCursorType']
+__all__ = ['OutputColumn', 'Column', 'HeavyDBOutputColumnType', 'HeavyDBColumnType',
+           'HeavyDBCursorType']
 
 from llvmlite import ir
 from rbc import typesystem, irutils
-from .buffer import Buffer, OmnisciBufferType, BufferType
-from .column_list import OmnisciColumnListType
+from .buffer import Buffer, HeavyDBBufferType, BufferType
+from .column_list import HeavyDBColumnListType
 from rbc.targetinfo import TargetInfo
 from numba.core import extending, types
 
@@ -18,21 +18,21 @@
 int32_t = ir.IntType(32)
 
 
-class OmnisciColumnType(OmnisciBufferType):
-    """Omnisci Column type for RBC typesystem.
+class HeavyDBColumnType(HeavyDBBufferType):
+    """Heavydb Column type for RBC typesystem.
     """
     @property
     def pass_by_value(self):
-        omnisci_version = TargetInfo().software[1][:3]
-        return omnisci_version <= (5, 7, 0)
+        heavydb_version = TargetInfo().software[1][:3]
+        return heavydb_version <= (5, 7, 0)
 
     def match(self, other):
         if type(self) is type(other):
             return self[0] == other[0]
 
 
-class OmnisciOutputColumnType(OmnisciColumnType):
-    """Omnisci OutputColumn type for RBC typesystem.
+class HeavyDBOutputColumnType(HeavyDBColumnType):
+    """Heavydb OutputColumn type for RBC typesystem.
 
     OutputColumn is the same as Column but introduced to distinguish
     the input and output arguments of UDTFs.
@@ -48,8 +48,8 @@ class OutputColumn(Column):
 
 
 @extending.intrinsic
-def omnisci_column_set_null_(typingctx, col_var, row_idx):
-    # Float values are serialized as integers by OmniSciDB
+def heavydb_column_set_null_(typingctx, col_var, row_idx):
+    # Float values are serialized as integers by HeavyDB
     # For reference, here is the conversion table for float and double
     #   FLOAT:  1.1754944e-38            -> 8388608
     #   DOUBLE: 2.2250738585072014e-308  -> 4503599627370496
@@ -75,14 +75,14 @@ def codegen(context, builder, signature, args):
 
 
 @extending.overload_method(BufferType, 'set_null')
-def omnisci_column_set_null(col_var, index):
+def heavydb_column_set_null(col_var, index):
     def impl(col_var, index):
-        return omnisci_column_set_null_(col_var, index)
+        return heavydb_column_set_null_(col_var, index)
     return impl
 
 
 @extending.intrinsic
-def omnisci_column_is_null_(typingctx, col_var, row_idx):
+def heavydb_column_is_null_(typingctx, col_var, row_idx):
     T = col_var.eltype
     sig = types.boolean(col_var, row_idx)
 
@@ -104,23 +104,23 @@ def codegen(context, builder, signature, args):
 
 
 @extending.overload_method(BufferType, 'is_null')
-def omnisci_column_is_null(col_var, row_idx):
+def heavydb_column_is_null(col_var, row_idx):
     def impl(col_var, row_idx):
-        return omnisci_column_is_null_(col_var, row_idx)
+        return heavydb_column_is_null_(col_var, row_idx)
     return impl
 
 
-class OmnisciCursorType(typesystem.Type):
+class HeavyDBCursorType(typesystem.Type):
 
     @classmethod
     def preprocess_args(cls, args):
         assert len(args) == 1
         params = []
         for p in args[0]:
-            if not isinstance(p, (OmnisciColumnType, OmnisciColumnListType)):
+            if not isinstance(p, (HeavyDBColumnType, HeavyDBColumnListType)):
                 # map Cursor<T ...> to Cursor<Column<T> ...>
                 c = p.copy()
-                p = OmnisciColumnType((c,), **c._params)
+                p = HeavyDBColumnType((c,), **c._params)
                 c._params.clear()
             params.append(p)
         return (tuple(params),)
diff --git a/rbc/heavyai/column_list.py b/rbc/heavyai/column_list.py
index 87ccd0c2..3974eaec 100644
--- a/rbc/heavyai/column_list.py
+++ b/rbc/heavyai/column_list.py
@@ -1,4 +1,4 @@
-__all__ = ['OmnisciColumnListType']
+__all__ = ['HeavyDBColumnListType']
 
 
 from numba.core import extending
@@ -6,8 +6,8 @@
 from rbc import structure_type
 
 
-class OmnisciColumnListType(Type):
-    """OmnisciColumnListType<T> is a typesystem custom type that
+class HeavyDBColumnListType(Type):
+    """HeavyDBColumnListType<T> is a typesystem custom type that
     represents a pointer type of the following struct type:
 
       {
@@ -25,24 +25,24 @@ def __typesystem_type__(self):
         length_t = Type.fromstring('int64 length')
         size_t = Type.fromstring('int64 size')
         return Type(ptrs_t, length_t, size_t).params(
-            NumbaPointerType=OmnisciColumnListNumbaType).pointer()
+            NumbaPointerType=HeavyDBColumnListNumbaType).pointer()
 
 
-class OmnisciColumnListNumbaType(structure_type.StructureNumbaPointerType):
+class HeavyDBColumnListNumbaType(structure_type.StructureNumbaPointerType):
     def get_getitem_impl(self):
         def impl(x, i):
             return x.ptrs[i]
         return impl
 
 
-@extending.overload_attribute(OmnisciColumnListNumbaType, 'nrows')
+@extending.overload_attribute(HeavyDBColumnListNumbaType, 'nrows')
 def get_nrows(clst):
     def impl(clst):
         return clst.size
     return impl
 
 
-@extending.overload_attribute(OmnisciColumnListNumbaType, 'ncols')
+@extending.overload_attribute(HeavyDBColumnListNumbaType, 'ncols')
 def get_ncols(clst):
     def impl(clst):
         return clst.length
diff --git a/rbc/heavyai/metatype.py b/rbc/heavyai/metatype.py
index 2274d49b..37a9afb8 100644
--- a/rbc/heavyai/metatype.py
+++ b/rbc/heavyai/metatype.py
@@ -1,10 +1,10 @@
 """Implements type meta
 """
 
-__all__ = ['OmnisciMetaType']
+__all__ = ['HeavyDBMetaType']
 
 
-class OmnisciMetaType(type):
+class HeavyDBMetaType(type):
 
     class_names = set()
 
diff --git a/rbc/heavyai/pipeline.py b/rbc/heavyai/pipeline.py
index ae81ee98..03b17374 100644
--- a/rbc/heavyai/pipeline.py
+++ b/rbc/heavyai/pipeline.py
@@ -92,7 +92,7 @@ def run_pass(self, state):
         return mutated
 
 
-class OmnisciCompilerPipeline(CompilerBase):
+class HeavyDBCompilerPipeline(CompilerBase):
     def define_pipelines(self):
         # define a new set of pipelines (just one in this case) and for ease
         # base it on an existing pipeline from the DefaultPassBuilder,
diff --git a/rbc/heavyai/python_operators.py b/rbc/heavyai/python_operators.py
index d36ed3e5..df16f2f7 100644
--- a/rbc/heavyai/python_operators.py
+++ b/rbc/heavyai/python_operators.py
@@ -13,7 +13,7 @@
 
 def overload_binary_cmp_op(op):
 
-    def omnisci_operator_impl(a, e):
+    def heavydb_operator_impl(a, e):
         if isinstance(a, ArrayPointer):
             if isinstance(e, ArrayPointer):
                 def impl(a, e):
@@ -35,7 +35,7 @@ def impl(a, e):
     decorate = extending.overload(op)
 
     def wrapper(overload_func):
-        return decorate(omnisci_operator_impl)
+        return decorate(heavydb_operator_impl)
 
     return wrapper
 
@@ -46,13 +46,13 @@ def wrapper(overload_func):
 @overload_binary_cmp_op(operator.le)
 @overload_binary_cmp_op(operator.gt)
 @overload_binary_cmp_op(operator.ge)
-def omnisci_binary_cmp_operator_fn(a, e):
+def heavydb_binary_cmp_operator_fn(a, e):
     pass
 
 
 def overload_binary_op(op, inplace=False):
 
-    def omnisci_operator_impl(a, b):
+    def heavydb_operator_impl(a, b):
         if isinstance(a, ArrayPointer) and isinstance(b, ArrayPointer):
             nb_dtype = a.eltype
 
@@ -73,7 +73,7 @@ def impl(a, b):
     decorate = extending.overload(op)
 
     def wrapper(overload_func):
-        return decorate(omnisci_operator_impl)
+        return decorate(heavydb_operator_impl)
 
     return wrapper
 
@@ -102,13 +102,13 @@ def wrapper(overload_func):
 @overload_binary_op(operator.isub, inplace=True)
 @overload_binary_op(operator.itruediv, inplace=True)
 @overload_binary_op(operator.ixor, inplace=True)
-def omnisci_binary_operator_fn(a, b):
+def heavydb_binary_operator_fn(a, b):
     pass
 
 
 def overload_unary_op(op):
 
-    def omnisci_operator_impl(a):
+    def heavydb_operator_impl(a):
         if isinstance(a, ArrayPointer):
             nb_dtype = a.eltype
 
@@ -123,7 +123,7 @@ def impl(a):
     decorate = extending.overload(op)
 
     def wrapper(overload_func):
-        return decorate(omnisci_operator_impl)
+        return decorate(heavydb_operator_impl)
 
     return wrapper
 
@@ -132,12 +132,12 @@ def wrapper(overload_func):
 @overload_unary_op(operator.abs)
 @overload_unary_op(operator.neg)
 @overload_unary_op(operator.pos)
-def omnisci_unary_op(a):
+def heavydb_unary_op(a):
     pass
 
 
 @extending.overload(operator.countOf)
-def omnisci_array_countOf(a, b):
+def heavydb_array_countOf(a, b):
     """
     Return the number of occurrences of b in a
     """
@@ -153,7 +153,7 @@ def impl_countOf(a, b):
 
 
 @extending.lower_builtin(operator.is_, ArrayPointer, ArrayPointer)
-def _omnisci_array_is(context, builder, sig, args):
+def _heavydb_array_is(context, builder, sig, args):
     """Implements `a is b` operation
     """
     [a, b] = args
@@ -161,7 +161,7 @@ def _omnisci_array_is(context, builder, sig, args):
 
 
 @extending.lower_builtin(operator.is_not, ArrayPointer, ArrayPointer)
-def _omnisci_array_is_not(context, builder, sig, args):
+def _heavydb_array_is_not(context, builder, sig, args):
     """Implements `a is not b` operation
     """
     [a, b] = args
@@ -169,7 +169,7 @@ def _omnisci_array_is_not(context, builder, sig, args):
 
 
 @extending.overload(operator.contains)
-def omnisci_array_contains(a, e):
+def heavydb_array_contains(a, e):
     """Implements `e in a` operation
     """
     if isinstance(a, ArrayPointer):
diff --git a/rbc/heavyai/table_function_manager.py b/rbc/heavyai/table_function_manager.py
index e081f43d..497028dc 100644
--- a/rbc/heavyai/table_function_manager.py
+++ b/rbc/heavyai/table_function_manager.py
@@ -1,4 +1,4 @@
-__all__ = ['OmnisciTableFunctionManagerType']
+__all__ = ['HeavyDBTableFunctionManagerType']
 
 
 from numba.core import extending, types
@@ -10,7 +10,7 @@
 from llvmlite import ir
 
 
-class OmnisciTableFunctionManagerType(Type):
+class HeavyDBTableFunctionManagerType(Type):
     """TableFunctionManager<> is a typesystem custom type that
     represents a class type with the following public interface:
 
@@ -25,21 +25,21 @@ class TableFunctionManager
     @property
     def __typesystem_type__(self):
         ptr_t = Type.fromstring("int8 ptr")
-        return Type(ptr_t).params(NumbaPointerType=OmnisciTableFunctionManagerNumbaType).pointer()
+        return Type(ptr_t).params(NumbaPointerType=HeavyDBTableFunctionManagerNumbaType).pointer()
 
 
-class OmnisciTableFunctionManagerNumbaType(structure_type.StructureNumbaPointerType):
+class HeavyDBTableFunctionManagerNumbaType(structure_type.StructureNumbaPointerType):
     pass
 
 
-error_msg = 'TableFunctionManager is only available in OmniSciDB 5.9 or newer (got %s)'
+error_msg = 'TableFunctionManager is only available in HeavyDB 5.9 or newer (got %s)'
 i8p = ir.IntType(8).as_pointer()
 i32 = ir.IntType(32)
 i64 = ir.IntType(64)
 
 
 @extending.intrinsic
-def omnisci_udtfmanager_error_message_(typingctx, mgr, msg):
+def heavydb_udtfmanager_error_message_(typingctx, mgr, msg):
     sig = types.int32(mgr, msg)
 
     target_info = TargetInfo()
@@ -71,15 +71,15 @@ def codegen(context, builder, signature, args):
     return sig, codegen
 
 
-@extending.overload_method(OmnisciTableFunctionManagerNumbaType, 'error_message')
-def omnisci_udtfmanager_error_message(mgr, msg):
+@extending.overload_method(HeavyDBTableFunctionManagerNumbaType, 'error_message')
+def heavydb_udtfmanager_error_message(mgr, msg):
     def impl(mgr, msg):
-        return omnisci_udtfmanager_error_message_(mgr, msg)
+        return heavydb_udtfmanager_error_message_(mgr, msg)
     return impl
 
 
 @extending.intrinsic
-def omnisci_udtfmanager_set_output_row_size_(typingctx, mgr, num_rows):
+def heavydb_udtfmanager_set_output_row_size_(typingctx, mgr, num_rows):
     sig = types.void(mgr, num_rows)
 
     target_info = TargetInfo()
@@ -100,8 +100,8 @@ def codegen(context, builder, sig, args):
     return sig, codegen
 
 
-@extending.overload_method(OmnisciTableFunctionManagerNumbaType, 'set_output_row_size')
-def omnisci_udtfmanager_set_output_row_size(mgr, num_rows):
+@extending.overload_method(HeavyDBTableFunctionManagerNumbaType, 'set_output_row_size')
+def heavydb_udtfmanager_set_output_row_size(mgr, num_rows):
     def impl(mgr, num_rows):
-        return omnisci_udtfmanager_set_output_row_size_(mgr, num_rows)
+        return heavydb_udtfmanager_set_output_row_size_(mgr, num_rows)
     return impl
diff --git a/rbc/heavyai/text_encoding.py b/rbc/heavyai/text_encoding.py
index 085f6b15..dabbe1cc 100644
--- a/rbc/heavyai/text_encoding.py
+++ b/rbc/heavyai/text_encoding.py
@@ -1,14 +1,14 @@
-'''Omnisci Bytes type that corresponds to Omnisci type TEXT ENCODED NONE.
+'''HeavyDB Bytes type that corresponds to HeavyDB type TEXT ENCODED NONE.
 '''
 
-__all__ = ['OmnisciTextEncodingDictType', 'TextEncodingDict']
+__all__ = ['HeavyDBTextEncodingDictType', 'TextEncodingDict']
 
-from .metatype import OmnisciMetaType
+from .metatype import HeavyDBMetaType
 from rbc import typesystem
 
 
-class OmnisciTextEncodingDictType(typesystem.Type):
-    """Omnisci Text Encoding Dict type for RBC typesystem.
+class HeavyDBTextEncodingDictType(typesystem.Type):
+    """HeavyDB Text Encoding Dict type for RBC typesystem.
     """
 
     @property
@@ -16,5 +16,5 @@ def __typesystem_type__(self):
         return typesystem.Type('int32')
 
 
-class TextEncodingDict(object, metaclass=OmnisciMetaType):
+class TextEncodingDict(object, metaclass=HeavyDBMetaType):
     pass
diff --git a/rbc/heavydb.py b/rbc/heavydb.py
index 1cad22a8..9063200b 100644
--- a/rbc/heavydb.py
+++ b/rbc/heavydb.py
@@ -14,13 +14,13 @@
 from .thrift import Client as ThriftClient
 from . import heavyai
 from .heavyai import (
-    OmnisciArrayType, OmnisciBytesType, OmnisciTextEncodingDictType,
-    OmnisciOutputColumnType, OmnisciColumnType,
-    OmnisciCompilerPipeline, OmnisciCursorType,
-    BufferMeta, OmnisciColumnListType, OmnisciTableFunctionManagerType)
+    HeavyDBArrayType, HeavyDBBytesType, HeavyDBTextEncodingDictType,
+    HeavyDBOutputColumnType, HeavyDBColumnType,
+    HeavyDBCompilerPipeline, HeavyDBCursorType,
+    BufferMeta, HeavyDBColumnListType, HeavyDBTableFunctionManagerType)
 from .targetinfo import TargetInfo
 from .irtools import compile_to_LLVM
-from .errors import ForbiddenNameError, OmnisciServerError
+from .errors import ForbiddenNameError, HeavyDBServerError
 from .utils import parse_version, version_date
 from . import ctools
 from . import typesystem
@@ -85,11 +85,11 @@ def _convert(node):
 
 
 def _global_heavydb():
-    """Implements singleton of a global RemoteOmnisci instance.
+    """Implements singleton of a global RemoteHeavyDB instance.
     """
     config = get_client_config()
     remotedb = dict(heavyai=RemoteHeavyDB,
-                    omnisci=RemoteOmnisci)[config['dbname']](**config)
+                    omnisci=RemoteHeavyDB)[config['dbname']](**config)
     while True:
         yield remotedb
 
@@ -179,7 +179,7 @@ def get_client_config(**config):
                                    ('omnisci', 'OMNISCI_CLIENT_CONF')]:
         conf_file = os.environ.get(client_conf_env, None)
         if conf_file is not None and not os.path.isfile(conf_file):
-            print('rbc.omnisci.get_client_config:'
+            print('rbc.heavydb.get_client_config:'
                   f' {client_conf_env}={conf_file!r}'
                   ' is not a file, ignoring.')
             conf_file = None
@@ -241,8 +241,8 @@ def is_udtf(sig):
     if sig[0].annotation().get('kind') == 'UDTF':
         return True
     for a in sig[1]:
-        if isinstance(a, (OmnisciOutputColumnType, OmnisciColumnType,
-                          OmnisciColumnListType, OmnisciTableFunctionManagerType)):
+        if isinstance(a, (HeavyDBOutputColumnType, HeavyDBColumnType,
+                          HeavyDBColumnListType, HeavyDBTableFunctionManagerType)):
             return True
     return False
 
@@ -328,7 +328,7 @@ def type_name_to_dtype(type_name):
         f'convert DatumType `{type_name}` to numpy dtype')
 
 
-class OmnisciQueryCapsule(RemoteCallCapsule):
+class HeavyDBQueryCapsule(RemoteCallCapsule):
 
     use_execute_cache = True
 
@@ -372,13 +372,13 @@ class RemoteHeavyDB(RemoteJIT):
 
     .. code:: python
 
-        omnisci = RemoteOmnisci(host=..., port=...)
+        heavydb = RemoteHeavyDB(host=..., port=...)
 
-        @omnisci('int(int, int)')
+        @heavydb('int(int, int)')
         def add(a, b):
             return a + b
 
-        omnisci.register()
+        heavydb.register()
 
     Use pymapd, for instance, to make a SQL query `select add(c1,
     c2) from table`
@@ -388,23 +388,23 @@ def add(a, b):
 
     typesystem_aliases = dict(
         bool='bool8',
-        Array='OmnisciArrayType',
-        Bytes='OmnisciBytesType<char8>',
-        Cursor='OmnisciCursorType',
-        Column='OmnisciColumnType',
-        OutputColumn='OmnisciOutputColumnType',
+        Array='HeavyDBArrayType',
+        Bytes='HeavyDBBytesType<char8>',
+        Cursor='HeavyDBCursorType',
+        Column='HeavyDBColumnType',
+        OutputColumn='HeavyDBOutputColumnType',
         RowMultiplier='int32|sizer=RowMultiplier',
         ConstantParameter='int32|sizer=ConstantParameter',
         SpecifiedParameter='int32|sizer=SpecifiedParameter',
         Constant='int32|sizer=Constant',
         PreFlight='int32|sizer=PreFlight',
-        ColumnList='OmnisciColumnListType',
-        TextEncodingDict='OmnisciTextEncodingDictType',
-        TableFunctionManager='OmnisciTableFunctionManagerType<>',
+        ColumnList='HeavyDBColumnListType',
+        TextEncodingDict='HeavyDBTextEncodingDictType',
+        TableFunctionManager='HeavyDBTableFunctionManagerType<>',
         UDTF='int32|kind=UDTF'
     )
 
-    remote_call_capsule_cls = OmnisciQueryCapsule
+    remote_call_capsule_cls = HeavyDBQueryCapsule
     default_remote_call_hold = True
     supports_local_caller = False
 
@@ -413,10 +413,15 @@ def __init__(self,
                  password='HyperInteractive',
                  host='localhost',
                  port=6274,
-                 dbname='omnisci',
+                 dbname='heavyai',
                  **options):
         self.user = user
         self.password = password
+
+        # To-Do: Remove this once we stop supporting HeavyDB 5.9
+        _version = get_heavydb_version()
+        if _version and _version < (6, 0, 0) and dbname == 'heavyai':
+            dbname = 'omnisci'
         self.dbname = dbname
 
         thrift_filename = os.path.join(os.path.dirname(__file__),
@@ -473,7 +478,7 @@ def version(self):
             version = self.thrift_call('get_version')
             self._version = parse_version(version)
             if self._version[:2] < (5, 6):
-                msg = (f'OmniSciDB server v.{version} is too old (expected v.5.6 or newer) '
+                msg = (f'HeavyDB server v.{version} is too old (expected v.5.6 or newer) '
                        'and some features might not be available.')
                 warnings.warn(msg, PendingDeprecationWarning)
         return self._version
@@ -534,10 +539,10 @@ def thrift_call(self, name, *args, **kwargs):
                          r'|Cannot apply.*)',
                          msg.error_msg)
             if m:
-                raise OmnisciServerError(f'[Calcite] {m.group(1)}')
+                raise HeavyDBServerError(f'[Calcite] {m.group(1)}')
             m = re.match(r'.*Exception: (.*)', msg.error_msg)
             if m:
-                raise OmnisciServerError(f'{m.group(1)}')
+                raise HeavyDBServerError(f'{m.group(1)}')
             m = re.match(
                 r'(.*)\: No match found for function signature (.*)\(.*\)',
                 msg.error_msg
@@ -545,38 +550,38 @@ def thrift_call(self, name, *args, **kwargs):
             if m:
                 msg = (f"Undefined function call {m.group(2)!r} in"
                        f" SQL statement: {m.group(1)}")
-                raise OmnisciServerError(msg)
+                raise HeavyDBServerError(msg)
             m = re.match(r'.*SQL Error: (.*)', msg.error_msg)
             if m:
-                raise OmnisciServerError(f'{m.group(1)}')
+                raise HeavyDBServerError(f'{m.group(1)}')
             m = re.match(r'Could not bind *', msg.error_msg)
             if m:
-                raise OmnisciServerError(msg.error_msg)
+                raise HeavyDBServerError(msg.error_msg)
             m = re.match(r'Runtime extension functions registration is disabled.',
                          msg.error_msg)
             if m:
                 msg = (f"{msg.error_msg} Please use server options --enable-runtime-udf"
                        " and/or --enable-table-functions")
-                raise OmnisciServerError(msg)
+                raise HeavyDBServerError(msg)
 
             # TODO: catch more known server failures here.
             raise
 
     def get_tables(self):
-        """Return a list of table names stored in the OmnisciDB server.
+        """Return a list of table names stored in the HeavyDB server.
         """
         return self.thrift_call('get_tables', self.session_id)
 
     def get_table_details(self, table_name):
-        """Return details about OmnisciDB table.
+        """Return details about HeavyDB table.
         """
         return self.thrift_call('get_table_details',
                                 self.session_id, table_name)
 
     def load_table_columnar(self, table_name, **columnar_data):
-        """Load columnar data to OmnisciDB table.
+        """Load columnar data to HeavyDB table.
 
-        Warning: when connected to OmnisciDB < 5.3, the data is loaded
+        Warning: when connected to HeavyDB < 5.3, the data is loaded
           row-wise that will be very slow for large data sets.
 
         Parameters
@@ -683,7 +688,7 @@ def load_table_columnar(self, table_name, **columnar_data):
                     break
             if typeinfo is None:
                 raise ValueError(
-                    f'OmnisciDB `{table_name}` has no column `{column_name}`')
+                    f'HeavyDB `{table_name}` has no column `{column_name}`')
             datumtype = thrift.TDatumType._VALUES_TO_NAMES[typeinfo.type]
             nulls = [v is None for v in column_data]
             if typeinfo.is_array:
@@ -727,7 +732,7 @@ def load_table_columnar(self, table_name, **columnar_data):
                          self.session_id, table_name, columns)
 
     def _make_row_results_set(self, data):
-        # The following code is a stripped copy from omnisci/pymapd
+        # The following code is a stripped copy from heavyai/pymapd
 
         _typeattr = {
             'SMALLINT': 'int',
@@ -785,7 +790,7 @@ def query_requires_register(self, query):
         return names and re.search(r'\b(' + names + r')\b', query, re.I) is not None
 
     def sql_execute(self, query):
-        """Execute SQL query in OmnisciDB server.
+        """Execute SQL query in HeavyDB server.
 
         Parameters
         ----------
@@ -895,21 +900,21 @@ def _get_ext_arguments_map(self):
                 ('float32', 'float'),
                 ('float64', 'double'),
                 ('TextEncodingDict', 'TextEncodingDict'),
-                ('OmnisciTextEncodingDictType<>', 'TextEncodingDict'),
+                ('HeavyDBTextEncodingDictType<>', 'TextEncodingDict'),
                 ('TimeStamp', 'TimeStamp'),
         ]:
-            ext_arguments_map['OmnisciArrayType<%s>' % ptr_type] \
+            ext_arguments_map['HeavyDBArrayType<%s>' % ptr_type] \
                 = ext_arguments_map.get('Array<%s>' % T)
-            ext_arguments_map['OmnisciColumnType<%s>' % ptr_type] \
+            ext_arguments_map['HeavyDBColumnType<%s>' % ptr_type] \
                 = ext_arguments_map.get('Column<%s>' % T)
-            ext_arguments_map['OmnisciOutputColumnType<%s>' % ptr_type] \
+            ext_arguments_map['HeavyDBOutputColumnType<%s>' % ptr_type] \
                 = ext_arguments_map.get('Column<%s>' % T)
-            ext_arguments_map['OmnisciColumnListType<%s>' % ptr_type] \
+            ext_arguments_map['HeavyDBColumnListType<%s>' % ptr_type] \
                 = ext_arguments_map.get('ColumnList<%s>' % T)
-            ext_arguments_map['OmnisciOutputColumnListType<%s>' % ptr_type] \
+            ext_arguments_map['HeavyDBOutputColumnListType<%s>' % ptr_type] \
                 = ext_arguments_map.get('ColumnList<%s>' % T)
 
-        ext_arguments_map['OmnisciBytesType<char8>'] = ext_arguments_map.get('Bytes')
+        ext_arguments_map['HeavyDBBytesType<char8>'] = ext_arguments_map.get('Bytes')
 
         values = list(ext_arguments_map.values())
         for v, n in thrift.TExtArgumentType._VALUES_TO_NAMES.items():
@@ -1022,12 +1027,12 @@ def retrieve_targets(self):
                 target_info.add_library('m')
                 target_info.add_library('stdio')
                 target_info.add_library('stdlib')
-                target_info.add_library('omniscidb')
+                target_info.add_library('heavydb')
             elif target_info.is_gpu and self.version >= (5, 5):
                 target_info.add_library('libdevice')
 
             version_str = '.'.join(map(str, self.version[:3])) + self.version[3]
-            target_info.set('software', f'OmnisciDB {version_str}')
+            target_info.set('software', f'HeavyDB {version_str}')
 
             llvm_version = device_params.get('llvm_version')
             if llvm_version is not None:
@@ -1054,7 +1059,7 @@ def _make_udtf(self, caller, orig_sig, sig):
             v = '.'.join(map(str, self.version))
             raise RuntimeError(
                 'UDTFs with Column arguments require '
-                'omniscidb 5.4 or newer, currently '
+                'heavydb 5.4 or newer, currently '
                 'connected to ', v)
         thrift = self.thrift_client.thrift
 
@@ -1078,28 +1083,28 @@ def _make_udtf(self, caller, orig_sig, sig):
             annot = a.annotation()
 
             # process function annotations first to avoid appending annotations twice
-            if isinstance(a, OmnisciTableFunctionManagerType):
+            if isinstance(a, HeavyDBTableFunctionManagerType):
                 function_annotations['uses_manager'] = 'True'
                 consumed_index += 1
                 continue
 
             annotations.append(annot)
 
-            if isinstance(a, OmnisciCursorType):
+            if isinstance(a, HeavyDBCursorType):
                 sqlArgTypes.append(self.type_to_extarg('Cursor'))
                 for a_ in a.as_consumed_args:
                     assert not isinstance(
-                        a_, OmnisciOutputColumnType), (a_)
+                        a_, HeavyDBOutputColumnType), (a_)
                     inputArgTypes.append(self.type_to_extarg(a_))
                     consumed_index += 1
 
             else:
-                if isinstance(a, OmnisciOutputColumnType):
+                if isinstance(a, HeavyDBOutputColumnType):
                     atype = self.type_to_extarg(a)
                     outputArgTypes.append(atype)
                 else:
                     atype = self.type_to_extarg(a)
-                    if isinstance(a, (OmnisciColumnType, OmnisciColumnListType)):
+                    if isinstance(a, (HeavyDBColumnType, HeavyDBColumnListType)):
                         sqlArgTypes.append(self.type_to_extarg('Cursor'))
                         inputArgTypes.append(atype)
                     else:
@@ -1127,12 +1132,12 @@ def _make_udtf(self, caller, orig_sig, sig):
             annotations)
 
     def _make_udtf_old(self, caller, orig_sig, sig):
-        # old style UDTF for omniscidb <= 5.3, to be deprecated
+        # old style UDTF for heavydb <= 5.3, to be deprecated
         if self.version >= (5, 4):
             v = '.'.join(map(str, self.version))
             raise RuntimeError(
                 'Old-style UDTFs require '
-                'omniscidb 5.3 or older, currently '
+                'heavydb 5.3 or older, currently '
                 'connected to ', v)
         thrift = self.thrift_client.thrift
 
@@ -1234,10 +1239,10 @@ def _register(self):
                                 sig.set_mangling('__%s_%s' % (device, i))
 
                         if sig_is_udtf:
-                            # new style UDTF, requires omniscidb version >= 5.4
+                            # new style UDTF, requires heavydb version >= 5.4
                             udtfs_map[fid] = self._make_udtf(caller, orig_sig, sig)
                         elif is_old_udtf:
-                            # old style UDTF for omniscidb <= 5.3, to be deprecated
+                            # old style UDTF for heavydb <= 5.3, to be deprecated
                             udtfs_map[fid] = self._make_udtf_old(caller, orig_sig, sig)
                         else:
                             udfs_map[fid] = self._make_udf(caller, orig_sig, sig)
@@ -1247,7 +1252,7 @@ def _register(self):
                 llvm_module, succesful_fids = compile_to_LLVM(
                     functions_and_signatures,
                     target_info,
-                    pipeline_class=OmnisciCompilerPipeline,
+                    pipeline_class=HeavyDBCompilerPipeline,
                     user_defined_llvm_ir=self.user_defined_llvm_ir.get(device),
                     debug=self.debug)
 
@@ -1338,10 +1343,10 @@ def caller_signature(self, signature: typesystem.Type):
                     if sizer not in user_specified_output_buffer_sizers:
                         continue
                     atype.annotation(sizer=sizer)
-                elif isinstance(atype, OmnisciTableFunctionManagerType):
+                elif isinstance(atype, HeavyDBTableFunctionManagerType):
                     continue
-                elif isinstance(atype, OmnisciOutputColumnType):
-                    rtypes.append(atype.copy(OmnisciColumnType))
+                elif isinstance(atype, HeavyDBOutputColumnType):
+                    rtypes.append(atype.copy(HeavyDBColumnType))
                     continue
                 atypes.append(atype)
             rtype = typesystem.Type(*rtypes, **dict(struct_is_tuple=True))
@@ -1392,28 +1397,28 @@ def format_type(self, typ: typesystem.Type):
         use_typename = False
         if typ.is_struct and typ._params.get('struct_is_tuple'):
             return f'({", ".join(map(self.format_type, typ))})'
-        if isinstance(typ, OmnisciOutputColumnType):
+        if isinstance(typ, HeavyDBOutputColumnType):
             p = tuple(map(self.format_type, typ[0]))
             typ = typesystem.Type(('OutputColumn',) + p, **typ._params)
-        elif isinstance(typ, OmnisciColumnType):
+        elif isinstance(typ, HeavyDBColumnType):
             p = tuple(map(self.format_type, typ[0]))
             typ = typesystem.Type(('Column',) + p, **typ._params)
-        elif isinstance(typ, OmnisciColumnListType):
+        elif isinstance(typ, HeavyDBColumnListType):
             p = tuple(map(self.format_type, typ[0]))
             typ = typesystem.Type(('ColumnList',) + p, **typ._params)
-        elif isinstance(typ, OmnisciArrayType):
+        elif isinstance(typ, HeavyDBArrayType):
             p = tuple(map(self.format_type, typ[0]))
             typ = typesystem.Type(('Array',) + p, **typ._params)
-        elif isinstance(typ, OmnisciCursorType):
+        elif isinstance(typ, HeavyDBCursorType):
             p = tuple(map(self.format_type, typ[0]))
             typ = typesystem.Type(('Cursor',) + p, **typ._params)
-        elif isinstance(typ, OmnisciBytesType):
+        elif isinstance(typ, HeavyDBBytesType):
             typ = typ.copy().params(typename='Bytes')
             use_typename = True
-        elif isinstance(typ, OmnisciTextEncodingDictType):
+        elif isinstance(typ, HeavyDBTextEncodingDictType):
             typ = typ.copy().params(typename='TextEncodingDict')
             use_typename = True
-        elif isinstance(typ, OmnisciTableFunctionManagerType):
+        elif isinstance(typ, HeavyDBTableFunctionManagerType):
             typ = typ.copy().params(typename='TableFunctionManager')
             use_typename = True
         elif is_sizer(typ):
@@ -1451,9 +1456,9 @@ def remote_call(self, func, ftype: typesystem.Type, arguments: tuple, hold=False
                 else:
                     a = a.execute(hold=True).lstrip('SELECT ')
 
-            if isinstance(atype, (OmnisciColumnType, OmnisciColumnListType)):
+            if isinstance(atype, (HeavyDBColumnType, HeavyDBColumnListType)):
                 args.append(f'CURSOR({a})')
-            elif isinstance(atype, OmnisciBytesType):
+            elif isinstance(atype, HeavyDBBytesType):
                 if isinstance(a, bytes):
                     a = repr(a.decode())
                 elif isinstance(a, str):
diff --git a/rbc/libfuncs.py b/rbc/libfuncs.py
index a41c3446..2c84b36a 100644
--- a/rbc/libfuncs.py
+++ b/rbc/libfuncs.py
@@ -22,8 +22,8 @@ def get(libname, _cache={}):
             r = NVVMIntrinsics()
         elif libname == 'llvm':
             r = LLVMIntrinsics()
-        elif libname == 'omniscidb':
-            r = OmnisciDB()
+        elif libname == 'heavydb':
+            r = HeavyDB()
         else:
             raise ValueError(f'Unknown library {libname}')
         _cache[libname] = r
@@ -46,9 +46,9 @@ def check(self, fname):
         return False
 
 
-class OmnisciDB(Library):
+class HeavyDB(Library):
 
-    name = 'omniscidb'
+    name = 'heavydb'
 
     _function_names = list('''
     allocate_varlen_buffer set_output_row_size
diff --git a/rbc/remotejit.py b/rbc/remotejit.py
index bb460646..3cc37a5a 100644
--- a/rbc/remotejit.py
+++ b/rbc/remotejit.py
@@ -14,10 +14,7 @@
 from .thrift import Server, Dispatcher, dispatchermethod, Data, Client
 from .utils import get_local_ip, UNSPECIFIED
 from .targetinfo import TargetInfo
-# XXX WIP: the OmnisciCompilerPipeline is no longer omnisci-specific because
-# we support Arrays even without omnisci, so it must be renamed and moved
-# somewhere elsef
-from .heavyai import OmnisciCompilerPipeline
+from .heavyai import HeavyDBCompilerPipeline
 
 
 def isfunctionlike(obj):
@@ -359,7 +356,7 @@ def describe(self):
                     llvm_module, succesful_fids = irtools.compile_to_LLVM(
                         [(self.func, signatures_map)],
                         target_info,
-                        pipeline_class=OmnisciCompilerPipeline,
+                        pipeline_class=HeavyDBCompilerPipeline,
                         debug=self.remotejit.debug)
                     lst.append(str(llvm_module))
         lst.append(f'{"":-^80}')
@@ -814,7 +811,7 @@ def remote_compile(self, func, ftype: Type, target_info: TargetInfo):
             llvm_module, succesful_fids = irtools.compile_to_LLVM(
                 [(func, {0: ftype})],
                 target_info,
-                pipeline_class=OmnisciCompilerPipeline,
+                pipeline_class=HeavyDBCompilerPipeline,
                 debug=self.debug)
         ir = str(llvm_module)
         mangled_signatures = ';'.join([s.mangle() for s in [ftype]])
diff --git a/rbc/stdlib/creation_functions.py b/rbc/stdlib/creation_functions.py
index cc98fae5..75715784 100644
--- a/rbc/stdlib/creation_functions.py
+++ b/rbc/stdlib/creation_functions.py
@@ -105,7 +105,7 @@ def _array_api_triu(x, k=0):
 
 
 @expose.implements('full')
-def _omnisci_np_full(shape, fill_value, dtype=None):
+def _impl__full(shape, fill_value, dtype=None):
     """
     Return a new array of given shape and type, filled with fill_value.
     """
@@ -119,7 +119,7 @@ def impl(shape, fill_value, dtype=None):
 
 
 @expose.implements('full_like')
-def _omnisci_np_full_like(a, fill_value, dtype=None):
+def _impl_full_like(a, fill_value, dtype=None):
     """
     Return a full array with the same shape and type as a given array.
     """
@@ -138,7 +138,7 @@ def impl(a, fill_value, dtype=None):
 
 
 @expose.implements('empty_like')
-def _omnisci_np_empty_like(a, dtype=None):
+def _impl_empty_like(a, dtype=None):
     """
     Return a new array with the same shape and type as a given array.
     """
@@ -154,7 +154,7 @@ def impl(a, dtype=None):
 
 
 @expose.implements('empty')
-def _omnisci_np_empty(shape, dtype=None):
+def _impl_empty(shape, dtype=None):
     """
     Return a new array of given shape and type, without initializing entries.
     """
@@ -172,7 +172,7 @@ def impl(shape, dtype=None):
 
 
 @expose.implements('zeros')
-def _omnisci_np_zeros(shape, dtype=None):
+def _impl_zeros(shape, dtype=None):
     """
     Return a new array of given shape and type, filled with zeros.
     """
@@ -186,7 +186,7 @@ def impl(shape, dtype=None):
 
 
 @expose.implements('zeros_like')
-def _omnisci_np_zeros_like(a, dtype=None):
+def _impl_zeros_like(a, dtype=None):
     """
     Return an array of zeros with the same shape and type as a given array.
     """
@@ -204,7 +204,7 @@ def impl(a, dtype=None):
 
 
 @expose.implements('ones')
-def _omnisci_np_ones(shape, dtype=None):
+def _impl_ones(shape, dtype=None):
     """
     Return a new array of given shape and type, filled with ones.
     """
@@ -218,7 +218,7 @@ def impl(shape, dtype=None):
 
 
 @expose.implements('ones_like')
-def _omnisci_np_ones_like(a, dtype=None):
+def _impl_ones_like(a, dtype=None):
     """
     Return an array of ones with the same shape and type as a given array.
     """
@@ -236,7 +236,7 @@ def impl(a, dtype=None):
 
 
 @extending.overload_method(ArrayPointer, 'fill')
-def _omnisci_array_fill(x, v):
+def _impl_array_fill(x, v):
     """
     Fill the array with a scalar value.
     """
@@ -248,7 +248,7 @@ def impl(x, v):
 
 
 @expose.implements('cumsum', api=API.NUMPY_API)
-def _omnisci_np_cumsum(a):
+def _impl_cumsum(a):
     """
     Return the cumulative sum of the elements along a given axis.
     """
diff --git a/rbc/stdlib/elementwise_functions.py b/rbc/stdlib/elementwise_functions.py
index 063ac937..65ecd75b 100644
--- a/rbc/stdlib/elementwise_functions.py
+++ b/rbc/stdlib/elementwise_functions.py
@@ -42,7 +42,7 @@
 
 # math functions
 @binary_expose.implements(np.add)
-def _omnisci_add(x1, x2):
+def _impl_add(x1, x2):
     """
     Calculates the sum for each element x1_i of the input array x1 with the respective element
     x2_i of the input array x2.
@@ -51,7 +51,7 @@ def _omnisci_add(x1, x2):
 
 
 @binary_expose.implements(np.subtract)
-def _omnisci_ufunc_subtract(x1, x2):
+def _impl_ufunc_subtract(x1, x2):
     """
     Calculates the difference for each element x1_i of the input array x1 with the respective
     element x2_i of the input array x2.
@@ -60,7 +60,7 @@ def _omnisci_ufunc_subtract(x1, x2):
 
 
 @binary_expose.implements(np.multiply)
-def _omnisci_ufunc_multiply(x1, x2):
+def _impl_ufunc_multiply(x1, x2):
     """
     Calculates the product for each element x1_i of the input array x1 with the respective element
     x2_i of the input array x2.
@@ -69,7 +69,7 @@ def _omnisci_ufunc_multiply(x1, x2):
 
 
 @binary_expose.implements(np.divide, ufunc_name='divide')
-def _omnisci_ufunc_divide(x1, x2):
+def _impl_ufunc_divide(x1, x2):
     """
     Calculates the division for each element x1_i of the input array x1 with the respective
     element x2_i of the input array x2.
@@ -78,7 +78,7 @@ def _omnisci_ufunc_divide(x1, x2):
 
 
 @binary_expose.implements(np.logaddexp)
-def _omnisci_ufunc_logaddexp(x1, x2):
+def _impl_ufunc_logaddexp(x1, x2):
     """
     Calculates the logarithm of the sum of exponentiations ``log(exp(x1) + exp(x2))`` for each
     element x1_i of the input array x1 with the respective element x2_i of the input array x2.
@@ -87,22 +87,22 @@ def _omnisci_ufunc_logaddexp(x1, x2):
 
 
 @binary_expose.implements(np.copysign, api=API.NUMPY_API)
-def _omnisci_ufunc_copysign(x1, x2):
+def _impl_ufunc_copysign(x1, x2):
     pass
 
 
 @binary_expose.implements(np.logaddexp2, api=API.NUMPY_API)
-def _omnisci_ufunc_logaddexp2(x1, x2):
+def _impl_ufunc_logaddexp2(x1, x2):
     pass
 
 
 @binary_expose.implements(np.true_divide, api=API.NUMPY_API)
-def _omnisci_ufunc_true_divide(x1, x2):
+def _impl_ufunc_true_divide(x1, x2):
     pass
 
 
 @binary_expose.implements(np.floor_divide)
-def _omnisci_ufunc_floor_divide(x1, x2):
+def _impl_ufunc_floor_divide(x1, x2):
     """
     Rounds the result of dividing each element x1_i of the input array x1 by the respective
     element x2_i of the input array x2 to the greatest (i.e., closest to +infinity) integer-value
@@ -112,12 +112,12 @@ def _omnisci_ufunc_floor_divide(x1, x2):
 
 
 @binary_expose.implements(np.power, ufunc_name='power', api=API.NUMPY_API)
-def _omnisci_ufunc_power(x1, x2):
+def _impl_ufunc_power(x1, x2):
     pass
 
 
 @binary_expose.implements(np.power, ufunc_name='pow')
-def _omnisci_ufunc_pow(x1, x2):
+def _impl_ufunc_pow(x1, x2):
     """
     Calculates an implementation-dependent approximation of exponentiation by raising each element
     x1_i (the base) of the input array x1 to the power of x2_i (the exponent), where x2_i is the
@@ -127,12 +127,12 @@ def _omnisci_ufunc_pow(x1, x2):
 
 
 @binary_expose.not_implemented('float_power')  # not supported by Numba
-def _omnisci_ufunc_float_power(x1, x2):
+def _impl_ufunc_float_power(x1, x2):
     pass
 
 
 @binary_expose.implements(np.remainder)
-def _omnisci_ufunc_remainder(x1, x2):
+def _impl_ufunc_remainder(x1, x2):
     """
     Returns the remainder of division for each element x1_i of the input array x1 and the
     respective element x2_i of the input array x2.
@@ -141,33 +141,33 @@ def _omnisci_ufunc_remainder(x1, x2):
 
 
 @binary_expose.implements(np.mod, ufunc_name='mod', api=API.NUMPY_API)
-def _omnisci_ufunc_mod(x1, x2):
+def _impl_ufunc_mod(x1, x2):
     pass
 
 
 @binary_expose.implements(np.fmod, api=API.NUMPY_API)
-def _omnisci_ufunc_fmod(x1, x2):
+def _impl_ufunc_fmod(x1, x2):
     pass
 
 
 @binary_expose.not_implemented('divmod')  # not supported by Numba
-def _omnisci_ufunc_divmod(x1, x2):
+def _impl_ufunc_divmod(x1, x2):
     pass
 
 
 @binary_expose.implements(np.gcd, api=API.NUMPY_API)
-def _omnisci_ufunc_gcd(x1, x2):
+def _impl_ufunc_gcd(x1, x2):
     pass
 
 
 @binary_expose.implements(np.lcm, api=API.NUMPY_API)
-def _omnisci_ufunc_lcm(x1, x2):
+def _impl_ufunc_lcm(x1, x2):
     pass
 
 
 # Bit-twiddling functions
 @binary_expose.implements(np.bitwise_and)
-def _omnisci_ufunc_bitwise_and(x1, x2):
+def _impl_ufunc_bitwise_and(x1, x2):
     """
     Computes the bitwise AND of the underlying binary representation of each element x1_iof the
     input array x1 with the respective element x2_i of the input array x2.
@@ -176,7 +176,7 @@ def _omnisci_ufunc_bitwise_and(x1, x2):
 
 
 @binary_expose.implements(np.bitwise_or)
-def _omnisci_ufunc_bitwise_or(x1, x2):
+def _impl_ufunc_bitwise_or(x1, x2):
     """
     Computes the bitwise OR of the underlying binary representation of each element x1_i of the
     input array x1 with the respective element x2_i of the input array x2.
@@ -185,7 +185,7 @@ def _omnisci_ufunc_bitwise_or(x1, x2):
 
 
 @binary_expose.implements(np.bitwise_xor)
-def _omnisci_ufunc_bitwise_xor(x1, x2):
+def _impl_ufunc_bitwise_xor(x1, x2):
     """
     Computes the bitwise XOR of the underlying binary representation of each element x1_i of the
     input array x1 with the respective element x2_i of the input array x2.
@@ -194,7 +194,7 @@ def _omnisci_ufunc_bitwise_xor(x1, x2):
 
 
 @binary_expose.implements(np.bitwise_not, ufunc_name='bitwise_not')
-def _omnisci_ufunc_bitwise_not(x1, x2):
+def _impl_ufunc_bitwise_not(x1, x2):
     """
     Computes the bitwise NOR of the underlying binary representation of each element x1_i of the
     input array x1 with the respective element x2_i of the input array x2.
@@ -203,12 +203,12 @@ def _omnisci_ufunc_bitwise_not(x1, x2):
 
 
 @binary_expose.implements(np.left_shift, api=API.NUMPY_API)
-def _omnisci_ufunc_left_shift(x1, x2):
+def _impl_ufunc_left_shift(x1, x2):
     pass
 
 
 @binary_expose.implements(np.left_shift, ufunc_name='bitwise_left_shift')
-def _omnisci_ufunc_bitwise_left_shift(x1, x2):
+def _impl_ufunc_bitwise_left_shift(x1, x2):
     """
     Shifts the bits of each element x1_i of the input array x1 to the left by appending x2_i
     (i.e., the respective element in the input array x2) zeros to the right of x1_i.
@@ -217,12 +217,12 @@ def _omnisci_ufunc_bitwise_left_shift(x1, x2):
 
 
 @binary_expose.implements(np.right_shift, api=API.NUMPY_API)
-def _omnisci_ufunc_right_shift(x1, x2):
+def _impl_ufunc_right_shift(x1, x2):
     pass
 
 
 @binary_expose.implements(np.right_shift, ufunc_name='bitwise_right_shift')
-def _omnisci_ufunc_bitwise_right_shift(x1, x2):
+def _impl_ufunc_bitwise_right_shift(x1, x2):
     """
     Shifts the bits of each element x1_i of the input array x1 to the right by appending x2_i
     (i.e., the respective element in the input array x2) zeros to the right of x1_i.
@@ -232,12 +232,12 @@ def _omnisci_ufunc_bitwise_right_shift(x1, x2):
 
 # trigonometric functions
 @binary_expose.implements(np.arctan2, api=API.NUMPY_API)
-def _omnisci_ufunc_arctan2(x1, x2):
+def _impl_ufunc_arctan2(x1, x2):
     pass
 
 
 @binary_expose.implements(np.arctan2, ufunc_name='atan2')
-def _omnisci_ufunc_atan2(x1, x2):
+def _impl_ufunc_atan2(x1, x2):
     """
     Calculates an implementation-dependent approximation of the inverse tangent of the quotient
     x1/x2, having domain [-infinity, +infinity] x ``[-infinity, +infinity]`` (where the x notation
@@ -248,13 +248,13 @@ def _omnisci_ufunc_atan2(x1, x2):
 
 
 @binary_expose.implements(np.hypot, api=API.NUMPY_API)
-def _omnisci_ufunc_hypot(x1, x2):
+def _impl_ufunc_hypot(x1, x2):
     pass
 
 
 # Comparison functions
 @binary_expose.implements(np.greater, dtype=typesystem.boolean8)
-def _omnisci_ufunc_greater(x1, x2):
+def _impl_ufunc_greater(x1, x2):
     """
     Computes the truth value of x1_i > x2_i for each element x1_i of the input array x1 with the
     respective element x2_i of the input array x2.
@@ -263,7 +263,7 @@ def _omnisci_ufunc_greater(x1, x2):
 
 
 @binary_expose.implements(np.greater_equal, dtype=typesystem.boolean8)
-def _omnisci_ufunc_greater_equal(x1, x2):
+def _impl_ufunc_greater_equal(x1, x2):
     """
     Computes the truth value of x1_i >= x2_i for each element x1_i of the input array x1 with the
     respective element x2_i of the input array x2.
@@ -272,7 +272,7 @@ def _omnisci_ufunc_greater_equal(x1, x2):
 
 
 @binary_expose.implements(np.less, dtype=typesystem.boolean8)
-def _omnisci_ufunc_less(x1, x2):
+def _impl_ufunc_less(x1, x2):
     """
     Computes the truth value of x1_i < x2_i for each element x1_i of the input array x1 with the
     respective element x2_i of the input array x2.
@@ -281,7 +281,7 @@ def _omnisci_ufunc_less(x1, x2):
 
 
 @binary_expose.implements(np.less_equal, dtype=typesystem.boolean8)
-def _omnisci_ufunc_less_equal(x1, x2):
+def _impl_ufunc_less_equal(x1, x2):
     """
     Computes the truth value of x1_i <= x2_i for each element x1_i of the input array x1 with the
     respective element x2_i of the input array x2.
@@ -290,7 +290,7 @@ def _omnisci_ufunc_less_equal(x1, x2):
 
 
 @binary_expose.implements(np.not_equal, dtype=typesystem.boolean8)
-def _omnisci_ufunc_not_equal(x1, x2):
+def _impl_ufunc_not_equal(x1, x2):
     """
     Computes the truth value of x1_i != x2_i for each element x1_i of the input array x1 with the
     respective element x2_i of the input array x2.
@@ -299,7 +299,7 @@ def _omnisci_ufunc_not_equal(x1, x2):
 
 
 @binary_expose.implements(np.equal, dtype=typesystem.boolean8)
-def _omnisci_ufunc_equal(x1, x2):
+def _impl_ufunc_equal(x1, x2):
     """
     Computes the truth value of x1_i == x2_i for each element x1_i of the input array x1 with the
     respective element x2_i of the input array x2.
@@ -308,7 +308,7 @@ def _omnisci_ufunc_equal(x1, x2):
 
 
 @binary_expose.implements(np.logical_and, dtype=typesystem.boolean8)
-def _omnisci_ufunc_logical_and(x1, x2):
+def _impl_ufunc_logical_and(x1, x2):
     """
     Computes the logical AND for each element x1_i of the input array x1 with the respective
     element x2_i of the input array x2.
@@ -317,7 +317,7 @@ def _omnisci_ufunc_logical_and(x1, x2):
 
 
 @binary_expose.implements(np.logical_or, dtype=typesystem.boolean8)
-def _omnisci_ufunc_logical_or(x1, x2):
+def _impl_ufunc_logical_or(x1, x2):
     """
     Computes the logical OR for each element x1_i of the input array x1 with the respective
     element x2_i of the input array x2.
@@ -326,7 +326,7 @@ def _omnisci_ufunc_logical_or(x1, x2):
 
 
 @binary_expose.implements(np.logical_xor, dtype=typesystem.boolean8)
-def _omnisci_ufunc_logical_xor(x1, x2):
+def _impl_ufunc_logical_xor(x1, x2):
     """
     "Computes the logical XOR for each element x1_i of the input array x1 with the respective
     element x2_i of the input array x2.
@@ -335,33 +335,33 @@ def _omnisci_ufunc_logical_xor(x1, x2):
 
 
 @binary_expose.implements(np.maximum, api=API.NUMPY_API)
-def _omnisci_ufunc_maximum(x1, x2):
+def _impl_ufunc_maximum(x1, x2):
     pass
 
 
 @binary_expose.implements(np.minimum, api=API.NUMPY_API)
-def _omnisci_ufunc_minimum(x1, x2):
+def _impl_ufunc_minimum(x1, x2):
     pass
 
 
 @binary_expose.implements(np.fmax, api=API.NUMPY_API)
-def _omnisci_ufunc_fmax(x1, x2):
+def _impl_ufunc_fmax(x1, x2):
     pass
 
 
 @binary_expose.implements(np.fmin, api=API.NUMPY_API)
-def _omnisci_ufunc_fmin(x1, x2):
+def _impl_ufunc_fmin(x1, x2):
     pass
 
 
 # Floating functions
 @binary_expose.implements(np.nextafter, api=API.NUMPY_API)
-def _omnisci_ufunc_nextafter(x1, x2):
+def _impl_ufunc_nextafter(x1, x2):
     pass
 
 
 @binary_expose.implements(np.ldexp, api=API.NUMPY_API)
-def _omnisci_ufunc_ldexp(x1, x2):
+def _impl_ufunc_ldexp(x1, x2):
     pass
 
 
@@ -369,7 +369,7 @@ def _omnisci_ufunc_ldexp(x1, x2):
 
 
 @unary_expose.implements(np.around, ufunc_name='round')
-def _omnisci_ufunc_round(a):
+def _impl_ufunc_round(a):
     """
     Rounds each element x_i of the input array x to the nearest integer-valued number.
     """
@@ -377,26 +377,26 @@ def _omnisci_ufunc_round(a):
 
 
 @unary_expose.implements(np.negative)
-def _omnisci_ufunc_negative(a):
+def _impl_ufunc_negative(a):
     """Computes the numerical negative of each element x_i (i.e., y_i = -x_i) of the
     input array x."""
     pass
 
 
 @unary_expose.implements(np.positive)
-def _omnisci_ufunc_positive(a):
+def _impl_ufunc_positive(a):
     """Computes the numerical positive of each element x_i (i.e., y_i = +x_i) of the
     input array x."""
     pass
 
 
 @unary_expose.implements(np.absolute, api=API.NUMPY_API)
-def _omnisci_ufunc_absolute(a):
+def _impl_ufunc_absolute(a):
     pass
 
 
 @unary_expose.implements(np.absolute, ufunc_name='abs')
-def _omnisci_ufunc_abs(a):
+def _impl_ufunc_abs(a):
     """
     Calculates the absolute value for each element x_i of the input array x (i.e., the element-
     wise result has the same magnitude as the respective element in x but has positive sign).
@@ -405,12 +405,12 @@ def _omnisci_ufunc_abs(a):
 
 
 @unary_expose.implements(np.rint, api=API.NUMPY_API)
-def _omnisci_ufunc_rint(a):
+def _impl_ufunc_rint(a):
     pass
 
 
 @unary_expose.implements(np.sign)
-def _omnisci_ufunc_sign(a):
+def _impl_ufunc_sign(a):
     """
     Returns an indication of the sign of a number for each element x_i of the input array x.
     """
@@ -418,17 +418,17 @@ def _omnisci_ufunc_sign(a):
 
 
 @unary_expose.implements(np.conj, ufunc_name='conj', api=API.NUMPY_API)
-def _omnisci_ufunc_conj(a):
+def _impl_ufunc_conj(a):
     pass
 
 
 @unary_expose.implements(np.conjugate, api=API.NUMPY_API)
-def _omnisci_ufunc_conjugate(a):
+def _impl_ufunc_conjugate(a):
     pass
 
 
 @unary_expose.implements(np.exp)
-def _omnisci_ufunc_exp(a):
+def _impl_ufunc_exp(a):
     """Calculates an implementation-dependent approximation to the exponential function, having
     domain.
 
@@ -441,12 +441,12 @@ def _omnisci_ufunc_exp(a):
 
 
 @unary_expose.implements(np.exp2, api=API.NUMPY_API)
-def _omnisci_ufunc_exp2(a):
+def _impl_ufunc_exp2(a):
     pass
 
 
 @unary_expose.implements(np.log)
-def _omnisci_ufunc_log(a):
+def _impl_ufunc_log(a):
     """
     Calculates an implementation-dependent approximation to the natural (base e) logarithm, having
     domain [0, +infinity] and codomain [-infinity, +infinity], for each element x_i of the input
@@ -456,7 +456,7 @@ def _omnisci_ufunc_log(a):
 
 
 @unary_expose.implements(np.log2)
-def _omnisci_ufunc_log2(a):
+def _impl_ufunc_log2(a):
     """Calculates an implementation-dependent approximation to the base 2 logarithm, having
     domain.
 
@@ -470,7 +470,7 @@ def _omnisci_ufunc_log2(a):
 
 
 @unary_expose.implements(np.log10)
-def _omnisci_ufunc_log10(a):
+def _impl_ufunc_log10(a):
     """Calculates an implementation-dependent approximation to the base 10 logarithm, having
     domain.
 
@@ -484,7 +484,7 @@ def _omnisci_ufunc_log10(a):
 
 
 @unary_expose.implements(np.expm1)
-def _omnisci_ufunc_expm1(a):
+def _impl_ufunc_expm1(a):
     """Calculates an implementation-dependent approximation to exp(x)-1, having domain [-infinity,
 
     +infinity] and codomain [-1, +infinity], for each element x_i of the
@@ -495,7 +495,7 @@ def _omnisci_ufunc_expm1(a):
 
 
 @unary_expose.implements(np.log1p)
-def _omnisci_ufunc_log1p(a):
+def _impl_ufunc_log1p(a):
     """
     Calculates an implementation-dependent approximation to log(1+x), where log refers to the
     natural (base e) logarithm, having domain [-1, +infinity] and codomain [-infinity, +infinity],
@@ -505,7 +505,7 @@ def _omnisci_ufunc_log1p(a):
 
 
 @unary_expose.implements(np.sqrt)
-def _omnisci_ufunc_sqrt(a):
+def _impl_ufunc_sqrt(a):
     """
     Calculates the square root, having domain [0, +infinity] and codomain [0, +infinity], for each
     element x_i of the input array x.
@@ -514,30 +514,30 @@ def _omnisci_ufunc_sqrt(a):
 
 
 @unary_expose.implements(np.square)
-def _omnisci_ufunc_square(a):
+def _impl_ufunc_square(a):
     """Squares (x_i * x_i) each element x_i of the input array x."""
     pass
 
 
 # @unary_expose.implements(np.cbrt)  # not supported by numba
 @unary_expose.not_implemented('cbrt')
-def _omnisci_ufunc_cbrt(a):
+def _impl_ufunc_cbrt(a):
     pass
 
 
 @unary_expose.implements(np.reciprocal, api=API.NUMPY_API)
-def _omnisci_ufunc_reciprocal(a):
+def _impl_ufunc_reciprocal(a):
     pass
 
 
 # Bit-twiddling functions
 @unary_expose.implements(np.invert, api=API.NUMPY_API)
-def _omnisci_ufunc_invert(a):
+def _impl_ufunc_invert(a):
     pass
 
 
 @unary_expose.implements(np.invert, ufunc_name='bitwise_invert')
-def _omnisci_ufunc_bitwise_invert(a):
+def _impl_ufunc_bitwise_invert(a):
     """
     Inverts (flips) each bit for each element x_i of the input array x.
     """
@@ -546,7 +546,7 @@ def _omnisci_ufunc_bitwise_invert(a):
 
 # trigonometric functions
 @unary_expose.implements(np.sin)
-def _omnisci_ufunc_sin(a):
+def _impl_ufunc_sin(a):
     """Calculates an implementation-dependent approximation to the sine, having domain (-infinity,
 
     +infinity) and codomain [-1, +1], for each element x_i of the input
@@ -557,7 +557,7 @@ def _omnisci_ufunc_sin(a):
 
 
 @unary_expose.implements(np.cos)
-def _omnisci_ufunc_cos(a):
+def _impl_ufunc_cos(a):
     """Calculates an implementation-dependent approximation to the cosine, having domain
     (-infinity,
 
@@ -569,7 +569,7 @@ def _omnisci_ufunc_cos(a):
 
 
 @unary_expose.implements(np.tan)
-def _omnisci_ufunc_tan(a):
+def _impl_ufunc_tan(a):
     """Calculates an implementation-dependent approximation to the tangent, having domain
     (-infinity,
 
@@ -581,12 +581,12 @@ def _omnisci_ufunc_tan(a):
 
 
 @unary_expose.implements(np.arcsin, api=API.NUMPY_API)
-def _omnisci_ufunc_arcsin(a):
+def _impl_ufunc_arcsin(a):
     pass
 
 
 @unary_expose.implements(np.arcsin, ufunc_name='asin')
-def _omnisci_ufunc_asin(a):
+def _impl_ufunc_asin(a):
     """
     Calculates an implementation-dependent approximation of the principal value of the inverse
     sine, having domain [-1, +1] and codomain [-π/2, +π/2] for each element x_i of the input array
@@ -596,12 +596,12 @@ def _omnisci_ufunc_asin(a):
 
 
 @unary_expose.implements(np.arccos, api=API.NUMPY_API)
-def _omnisci_ufunc_arccos(a):
+def _impl_ufunc_arccos(a):
     pass
 
 
 @unary_expose.implements(np.arccos, ufunc_name='acos')
-def _omnisci_ufunc_acos(a):
+def _impl_ufunc_acos(a):
     """
     Calculates an implementation-dependent approximation of the principal value of the inverse
     cosine, having domain [-1, +1] and codomain [+0, +π], for each element x_i of the input array
@@ -611,12 +611,12 @@ def _omnisci_ufunc_acos(a):
 
 
 @unary_expose.implements(np.arctan, api=API.NUMPY_API)
-def _omnisci_ufunc_arctan(a):
+def _impl_ufunc_arctan(a):
     pass
 
 
 @unary_expose.implements(np.arctan, ufunc_name='atan')
-def _omnisci_ufunc_atan(a):
+def _impl_ufunc_atan(a):
     """
     Calculates an implementation-dependent approximation of the principal value of the inverse
     tangent, having domain [-infinity, +infinity] and codomain [-π/2, +π/2], for each element x_i
@@ -626,7 +626,7 @@ def _omnisci_ufunc_atan(a):
 
 
 @unary_expose.implements(np.sinh)
-def _omnisci_ufunc_sinh(a):
+def _impl_ufunc_sinh(a):
     """Calculates an implementation-dependent approximation to the hyperbolic sine, having domain.
 
     [-infinity, +infinity] and codomain [-infinity, +infinity], for each
@@ -637,7 +637,7 @@ def _omnisci_ufunc_sinh(a):
 
 
 @unary_expose.implements(np.cosh)
-def _omnisci_ufunc_cosh(a):
+def _impl_ufunc_cosh(a):
     """Calculates an implementation-dependent approximation to the hyperbolic cosine, having
     domain.
 
@@ -649,7 +649,7 @@ def _omnisci_ufunc_cosh(a):
 
 
 @unary_expose.implements(np.tanh)
-def _omnisci_ufunc_tanh(a):
+def _impl_ufunc_tanh(a):
     """Calculates an implementation-dependent approximation to the hyperbolic tangent, having
     domain.
 
@@ -661,12 +661,12 @@ def _omnisci_ufunc_tanh(a):
 
 
 @unary_expose.implements(np.arcsinh, api=API.NUMPY_API)
-def _omnisci_ufunc_arcsinh(a):
+def _impl_ufunc_arcsinh(a):
     pass
 
 
 @unary_expose.implements(np.arcsinh, ufunc_name='asinh')
-def _omnisci_ufunc_asinh(a):
+def _impl_ufunc_asinh(a):
     """
     Calculates an implementation-dependent approximation to the inverse hyperbolic sine, having
     domain [-infinity, +infinity] and codomain [-infinity, +infinity], for each element x_i in the
@@ -676,12 +676,12 @@ def _omnisci_ufunc_asinh(a):
 
 
 @unary_expose.implements(np.arccosh, api=API.NUMPY_API)
-def _omnisci_ufunc_arccosh(a):
+def _impl_ufunc_arccosh(a):
     pass
 
 
 @unary_expose.implements(np.arccosh, ufunc_name='acosh')
-def _omnisci_ufunc_acosh(a):
+def _impl_ufunc_acosh(a):
     """
     Calculates an implementation-dependent approximation to the inverse hyperbolic cosine, having
     domain [+1, +infinity] and codomain [+0, +infinity], for each element x_i of the input array
@@ -691,12 +691,12 @@ def _omnisci_ufunc_acosh(a):
 
 
 @unary_expose.implements(np.arctanh, api=API.NUMPY_API)
-def _omnisci_ufunc_arctanh(a):
+def _impl_ufunc_arctanh(a):
     pass
 
 
 @unary_expose.implements(np.arctanh, ufunc_name='atanh')
-def _omnisci_ufunc_atanh(a):
+def _impl_ufunc_atanh(a):
     """
     Calculates an implementation-dependent approximation to the inverse hyperbolic tangent, having
     domain [-1, +1] and codomain [-infinity, +infinity], for each element x_i of the input array
@@ -706,28 +706,28 @@ def _omnisci_ufunc_atanh(a):
 
 
 @unary_expose.implements(np.degrees, api=API.NUMPY_API)
-def _omnisci_ufunc_degrees(a):
+def _impl_ufunc_degrees(a):
     pass
 
 
 @unary_expose.implements(np.radians, api=API.NUMPY_API)
-def _omnisci_ufunc_radians(a):
+def _impl_ufunc_radians(a):
     pass
 
 
 @unary_expose.implements(np.deg2rad, api=API.NUMPY_API)
-def _omnisci_ufunc_deg2rad(a):
+def _impl_ufunc_deg2rad(a):
     pass
 
 
 @unary_expose.implements(np.rad2deg, api=API.NUMPY_API)
-def _omnisci_ufunc_rad2deg(a):
+def _impl_ufunc_rad2deg(a):
     pass
 
 
 # Comparison functions
 @unary_expose.implements(np.logical_not, dtype=typesystem.boolean8)
-def _omnisci_ufunc_logical_not(a):
+def _impl_ufunc_logical_not(a):
     """
     Computes the logical NOT for each element x_i of the input array x.
     """
@@ -736,7 +736,7 @@ def _omnisci_ufunc_logical_not(a):
 
 # Floating functions
 @unary_expose.implements(np.isfinite, dtype=typesystem.boolean8)
-def _omnisci_ufunc_isfinite(a):
+def _impl_ufunc_isfinite(a):
     """
     Tests each element x_i of the input array x to determine if finite (i.e., not NaN and not
     equal to positive or negative infinity).
@@ -745,7 +745,7 @@ def _omnisci_ufunc_isfinite(a):
 
 
 @unary_expose.implements(np.isinf, dtype=typesystem.boolean8)
-def _omnisci_ufunc_isinf(a):
+def _impl_ufunc_isinf(a):
     """
     Tests each element x_i of the input array x to determine if equal to positive or negative
     infinity.
@@ -754,7 +754,7 @@ def _omnisci_ufunc_isinf(a):
 
 
 @unary_expose.implements(np.isnan, dtype=typesystem.boolean8)
-def _omnisci_ufunc_isnan(a):
+def _impl_ufunc_isnan(a):
     """
     Tests each element x_i of the input array x to determine whether the element is NaN.
     """
@@ -762,12 +762,12 @@ def _omnisci_ufunc_isnan(a):
 
 
 @unary_expose.implements(np.fabs, dtype=types.double, api=API.NUMPY_API)
-def _omnisci_ufunc_fabs(a):
+def _impl_ufunc_fabs(a):
     pass
 
 
 @unary_expose.implements(np.floor, dtype=types.double)
-def _omnisci_ufunc_floor(a):
+def _impl_ufunc_floor(a):
     """
     Rounds each element x_i of the input array x to the greatest (i.e., closest to +infinity)
     integer-valued number that is not greater than x_i.
@@ -776,7 +776,7 @@ def _omnisci_ufunc_floor(a):
 
 
 @unary_expose.implements(np.ceil, dtype=types.double)
-def _omnisci_ufunc_ceil(a):
+def _impl_ufunc_ceil(a):
     """
     Rounds each element x_i of the input array x to the smallest (i.e., closest to -infinity)
     integer-valued number that is not less than x_i.
@@ -785,7 +785,7 @@ def _omnisci_ufunc_ceil(a):
 
 
 @unary_expose.implements(np.trunc, dtype=types.double)
-def _omnisci_ufunc_trunc(a):
+def _impl_ufunc_trunc(a):
     """
     Rounds each element x_i of the input array x to the integer-valued number that is closest to
     but no greater than x_i.
@@ -796,18 +796,18 @@ def _omnisci_ufunc_trunc(a):
 # not supported?
 # @unary_expose.implements(np.isnat, dtype=types.int8)
 @unary_expose.not_implemented('isnat')
-def _omnisci_ufunc_isnat(a):
+def _impl_ufunc_isnat(a):
     pass
 
 
 # issue 152:
 @unary_expose.implements(np.signbit, dtype=typesystem.boolean8, api=API.NUMPY_API)
-def _omnisci_ufunc_signbit(a):
+def _impl_ufunc_signbit(a):
     pass
 
 
 @unary_expose.implements(np.spacing, dtype=types.double, api=API.NUMPY_API)
-def _omnisci_ufunc_spacing(a):
+def _impl_ufunc_spacing(a):
     pass
 
 
diff --git a/rbc/stdlib/statistical_functions.py b/rbc/stdlib/statistical_functions.py
index 6725bc57..f6fb65ec 100644
--- a/rbc/stdlib/statistical_functions.py
+++ b/rbc/stdlib/statistical_functions.py
@@ -34,7 +34,7 @@ def _get_type_limits(eltype):
 @extending.overload(max)
 @expose.implements('max')
 @extending.overload_method(ArrayPointer, 'max')
-def _omnisci_array_max(x):
+def _impl_array_max(x):
     """
     Calculates the maximum value of the input array x
     """
@@ -51,7 +51,7 @@ def _omnisci_array_max(x):
 
         def impl(x):
             if len(x) <= 0:
-                printf("omnisci_array_max: cannot find max of zero-sized array")  # noqa: E501
+                printf("impl_array_max: cannot find max of zero-sized array")  # noqa: E501
                 return min_value
             m = x[0]
             for i in range(len(x)):
@@ -65,7 +65,7 @@ def impl(x):
 @extending.overload(min)
 @expose.implements('min')
 @extending.overload_method(ArrayPointer, 'min')
-def _omnisci_array_min(x):
+def _impl_array_min(x):
     """
     Calculates the minimum value of the input array x.
     """
@@ -74,7 +74,7 @@ def _omnisci_array_min(x):
 
         def impl(x):
             if len(x) <= 0:
-                printf("omnisci_array_min: cannot find min of zero-sized array")  # noqa: E501
+                printf("impl_array_min: cannot find min of zero-sized array")  # noqa: E501
                 return max_value
             m = x[0]
             for i in range(len(x)):
@@ -88,7 +88,7 @@ def impl(x):
 @extending.overload(sum)
 @expose.implements('sum')
 @extending.overload_method(ArrayPointer, 'sum')
-def _omnisci_np_sum(a):
+def _impl_np_sum(a):
     """
     Calculates the sum of the input array x.
     """
@@ -104,7 +104,7 @@ def impl(a):
 
 @expose.implements('prod')
 @extending.overload_method(ArrayPointer, 'prod')
-def _omnisci_np_prod(a):
+def _impl_np_prod(a):
     """
     Calculates the product of input array x elements.
     """
@@ -120,7 +120,7 @@ def impl(a):
 
 @expose.implements('mean')
 @extending.overload_method(ArrayPointer, 'mean')
-def _omnisci_array_mean(x):
+def _impl_array_mean(x):
     """
     Calculates the arithmetic mean of the input array x.
     """
@@ -136,7 +136,7 @@ def impl(x):
 
 
 @expose.not_implemented('std')
-def _omnisci_array_std(x, axis=None, correction=0.0, keepdims=False):
+def _impl_array_std(x, axis=None, correction=0.0, keepdims=False):
     """
     Calculates the standard deviation of the input array x.
     """
@@ -144,7 +144,7 @@ def _omnisci_array_std(x, axis=None, correction=0.0, keepdims=False):
 
 
 @expose.not_implemented('var')
-def _omnisci_array_var(x, axis=None, correction=0.0, keepdims=False):
+def _impl_array_var(x, axis=None, correction=0.0, keepdims=False):
     """
     Calculates the variance of the input array x.
     """
diff --git a/rbc/targetinfo.py b/rbc/targetinfo.py
index f1c610a9..e805691e 100644
--- a/rbc/targetinfo.py
+++ b/rbc/targetinfo.py
@@ -362,7 +362,7 @@ def null_values(self):
         """
         null_values = self.info.get('null_values', {})
         if not null_values:
-            raise RuntimeError('null value support requires omniscidb-internal PR 5104')
+            raise RuntimeError('null value support requires heavydb-internal PR 5104')
         return null_values
 
     # TODO: info may also contain: count, threads, cores
diff --git a/setup.cfg b/setup.cfg
index e55babbf..f0b19473 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -13,8 +13,6 @@ parentdir_prefix =
 
 [flake8]
 per-file-ignores =
-    rbc/omnisci_backend/numpy_ufuncs.py: F822 # undefined name in __all__
-    rbc/omnisci_backend/numpy_funcs.py: F822
     rbc/stdlib/creation_functions.py: F822
     rbc/stdlib/data_type_functions.py: F822, E501
     rbc/stdlib/linear_algebra_functions.py: F822


Test patch:
diff --git a/.github/workflows/rbc_test.yml b/.github/workflows/rbc_test.yml
index dd667324..a4359758 100644
--- a/.github/workflows/rbc_test.yml
+++ b/.github/workflows/rbc_test.yml
@@ -46,7 +46,7 @@ jobs:
             python-version: '3.10'
             numba-version: '0.55'
 
-    needs: [lint, omniscidb]
+    needs: [lint, heavydb]
 
     steps:
       - name: Checkout code
@@ -95,8 +95,8 @@ jobs:
         run: |
           mamba run -n rbc pytest -sv -r A rbc/ -x
 
-  omniscidb:
-    name: OmnisciDB ${{ matrix.omniscidb-version }} - ${{ matrix.os }} - Numba v${{matrix.numba-version}} - Python v${{ matrix.python-version }} [${{ matrix.omniscidb-from }}]
+  heavydb:
+    name: Heavydb ${{ matrix.heavydb-version }} - ${{ matrix.os }} - Numba v${{matrix.numba-version}} - Python v${{ matrix.python-version }} [${{ matrix.heavydb-from }}]
     runs-on: ${{ matrix.os }}
     timeout-minutes: 20
     strategy:
@@ -105,21 +105,21 @@ jobs:
         os: [ubuntu-latest]
         python-version: ['3.9', '3.8', '3.7']
         numba-version: ['0.55', '0.54']
-        omniscidb-version: ['5.10', '5.9', '5.8', '5.7']
-        omniscidb-from: [conda]
+        heavydb-version: ['5.10', '5.9', '5.8', '5.7']
+        heavydb-from: [conda]
         include:
           - os: ubuntu-latest
             python-version: '3.10'
             numba-version: '0.55'
-            omniscidb-version: dev
+            heavydb-version: dev
             docker-image: omnisci/core-os-cpu-dev:latest
-            omniscidb-from: docker
+            heavydb-from: docker
           - os: ubuntu-latest
             python-version: '3.9'
             numba-version: '0.54'
-            omniscidb-version: dev
+            heavydb-version: dev
             docker-image: omnisci/core-os-cpu-dev:latest
-            omniscidb-from: docker
+            heavydb-from: docker
 
     needs: lint
 
@@ -143,18 +143,18 @@ jobs:
         run: |
           conda env config vars set MAMBA_NO_BANNER=1
 
-      # omniscidb must be run in an environment that is independent of rbc environment
-      - name: Install omniscidb v${{ matrix.omniscidb-version }} [conda]
+      # heavydb must be run in an environment that is independent of rbc environment
+      - name: Install heavydb v${{ matrix.heavydb-version }} [conda]
         shell: bash -l {0}
-        if: matrix.os == 'ubuntu-latest' && matrix.omniscidb-from == 'conda'
+        if: matrix.os == 'ubuntu-latest' && matrix.heavydb-from == 'conda'
         run: |
-          mamba create -n omniscidb-env omniscidb=${{ matrix.omniscidb-version }}*=*_cpu -c conda-forge
+          mamba create -n heavydb-env omniscidb=${{ matrix.heavydb-version }}*=*_cpu -c conda-forge
 
-      - name: Build Omniscidb docker image and run it [docker]
+      - name: Build heavydb docker image and run it [docker]
         shell: bash -l {0}
         env:
-          OMNISCIDB_DOCKER_IMAGE: ${{ matrix.docker-image }}
-        if: matrix.os == 'ubuntu-latest' && matrix.omniscidb-from == 'docker'
+          HEAVYDB_DOCKER_IMAGE: ${{ matrix.docker-image }}
+        if: matrix.os == 'ubuntu-latest' && matrix.heavydb-from == 'docker'
         run: |
           # force docker-compose installation
           mamba create -n docker docker-compose -c conda-forge
@@ -163,29 +163,29 @@ jobs:
           mamba run -n docker docker-compose up -d
           sleep 20
 
-      - name: omniscidb-env conda list [conda]
+      - name: heavydb-env conda list [conda]
         shell: bash -l {0}
-        if: matrix.os == 'ubuntu-latest' && matrix.omniscidb-from == 'conda'
+        if: matrix.os == 'ubuntu-latest' && matrix.heavydb-from == 'conda'
         run: |
-          mamba run -n omniscidb-env conda list
+          mamba run -n heavydb-env conda list
 
-      - name: Start Omniscidb [conda]
+      - name: Start heavydb [conda]
         shell: bash -l {0}
-        if: matrix.os == 'ubuntu-latest' && matrix.omniscidb-from == 'conda'
+        if: matrix.os == 'ubuntu-latest' && matrix.heavydb-from == 'conda'
         env:
-          OMNISCIDB_VERSION: ${{ matrix.omniscidb-version }}
+          heavydb_VERSION: ${{ matrix.heavydb-version }}
         run: |
           mkdir data
-          mamba run -n omniscidb-env omnisci_initdb data -f
-          mamba run -n omniscidb-env omnisci_server --version
+          mamba run -n heavydb-env omnisci_initdb data -f
+          mamba run -n heavydb-env omnisci_server --version
           RUN_FLAGS="--enable-runtime-udf --enable-table-functions"
-          if [[ ${OMNISCIDB_VERSION} == "5.10" ]]; then
+          if [[ ${heavydb_VERSION} == "5.10" ]]; then
             RUN_FLAGS="${RUN_FLAGS} --enable-dev-table-functions"
           fi
           echo ${RUN_FLAGS}
-          mamba run -n omniscidb-env omnisci_server $RUN_FLAGS \> omniscidb-output.txt 2\>\&1 \& echo \$! \> omniscidb.pid
+          mamba run -n heavydb-env omnisci_server $RUN_FLAGS \> heavydb-output.txt 2\>\&1 \& echo \$! \> heavydb.pid
           sleep 10
-          cat omniscidb.pid
+          cat heavydb.pid
 
       - name: Create rbc test environment v${{ matrix.python-version }}
         shell: bash -l {0}
@@ -212,11 +212,11 @@ jobs:
 
       - name: Run rbc tests [docker]
         shell: bash -l {0}
-        if: matrix.os == 'ubuntu-latest' && matrix.omniscidb-from == 'docker'
+        if: matrix.os == 'ubuntu-latest' && matrix.heavydb-from == 'docker'
         env:
-          OMNISCIDB_DEV_LABEL: ${{ 'docker-dev' }}
+          HEAVYDB_DEV_LABEL: ${{ 'docker-dev' }}
           EXPECTED_PYTHON_VERSION: ${{ matrix.python-version }}
-          EXPECTED_OMNISCIDB_VERSION: ${{ matrix.omniscidb-version }}
+          EXPECTED_HEAVYDB_VERSION: ${{ matrix.heavydb-version }}
           EXPECTED_NUMBA_VERSION: ${{ matrix.numba-version }}
           RBC_TESTS_FULL: TRUE
         run: |
@@ -224,50 +224,50 @@ jobs:
 
       - name: Run rbc tests
         shell: bash -l {0}
-        if: ${{ ! ( matrix.os == 'ubuntu-latest' && matrix.omniscidb-from == 'docker' ) }}
+        if: ${{ ! ( matrix.os == 'ubuntu-latest' && matrix.heavydb-from == 'docker' ) }}
         env:
           EXPECTED_PYTHON_VERSION: ${{ matrix.python-version }}
-          EXPECTED_OMNISCIDB_VERSION: ${{ matrix.omniscidb-version }}
+          EXPECTED_HEAVYDB_VERSION: ${{ matrix.heavydb-version }}
           EXPECTED_NUMBA_VERSION: ${{ matrix.numba-version }}
           RBC_TESTS_FULL: TRUE
         run: |
           mamba run -n rbc pytest -sv -r A rbc/tests/ -x -k heavyai
 
-      - name: Show Omniscidb conda logs on failure [conda]
+      - name: Show Heavydb conda logs on failure [conda]
         shell: bash -l {0}
-        if: failure() && matrix.os == 'ubuntu-latest' && matrix.omniscidb-from == 'conda'
+        if: failure() && matrix.os == 'ubuntu-latest' && matrix.heavydb-from == 'conda'
         run: |
-          mamba run -n omniscidb-env cat data/mapd_log/omnisci_server.INFO
-          mamba run -n omniscidb-env cat data/mapd_log/omnisci_server.WARNING
-          mamba run -n omniscidb-env cat data/mapd_log/omnisci_server.ERROR
+          mamba run -n heavydb-env cat data/mapd_log/omnisci_server.INFO
+          mamba run -n heavydb-env cat data/mapd_log/omnisci_server.WARNING
+          mamba run -n heavydb-env cat data/mapd_log/omnisci_server.ERROR
 
-      - name: Show Omniscidb docker logs on failure [docker]
+      - name: Show Heavydb docker logs on failure [docker]
         shell: bash -l {0}
-        if: failure() && matrix.os == 'ubuntu-latest' && matrix.omniscidb-from == 'docker'
+        if: failure() && matrix.os == 'ubuntu-latest' && matrix.heavydb-from == 'docker'
         run: |
           mamba run -n docker docker-compose top  # to check if server is still alive
           mamba run -n docker docker-compose exec -T ls
 
-      - name: Stop Omniscidb server [conda]
+      - name: Stop Heavydb server [conda]
         shell: bash -l {0}
-        if: matrix.os == 'ubuntu-latest' && matrix.omniscidb-from == 'conda'
+        if: matrix.os == 'ubuntu-latest' && matrix.heavydb-from == 'conda'
         run: |
-          test -f omniscidb.pid && kill -INT `cat omniscidb.pid`
+          test -f heavydb.pid && kill -INT `cat heavydb.pid`
           sleep 5
 
-      - name: Show Omniscidb server output [conda]
+      - name: Show Heavydb server output [conda]
         shell: bash -l {0}
-        if: matrix.os == 'ubuntu-latest' && matrix.omniscidb-from == 'conda'
+        if: matrix.os == 'ubuntu-latest' && matrix.heavydb-from == 'conda'
         run: |
-          cat omniscidb-output.txt
+          cat heavydb-output.txt
 
-      - name: Show Omniscidb docker logs on failure [docker]
+      - name: Show Heavydb docker logs on failure [docker]
         shell: bash -l {0}
         timeout-minutes: 2
-        if: ${{ failure() && matrix.os == 'ubuntu-latest' && matrix.omniscidb-from == 'docker' }}
+        if: ${{ failure() && matrix.os == 'ubuntu-latest' && matrix.heavydb-from == 'docker' }}
         run: |
-          mamba run -n docker docker-compose logs --no-color --tail=10000 -f -t \> omniscidb-docker.log
-          cat omniscidb-docker.log
+          mamba run -n docker docker-compose logs --no-color --tail=10000 -f -t \> heavydb-docker.log
+          cat heavydb-docker.log
 
   eval-notebooks:
       runs-on: ubuntu-latest
@@ -293,12 +293,12 @@ jobs:
           run: |
             mamba install -c conda-forge omniscidb nbval ibis-omniscidb matplotlib pandas ibis-framework
 
-        - name: Start omniscidb server
+        - name: Start heavydb server
           shell: bash -l {0}
           run: |
             mkdir data && omnisci_initdb data -f
             omnisci_server --version
-            omnisci_server --enable-runtime-udf --enable-table-functions 2>&1 > omniscidb-output.txt &
+            omnisci_server --enable-runtime-udf --enable-table-functions 2>&1 > heavydb-output.txt &
             sleep 10
 
         - name: conda config
@@ -316,4 +316,4 @@ jobs:
             pip install -e .
             pytest -v -rs --nbval notebooks/ -x
             pkill -f omnisci_server
-            cat omniscidb-output.txt
+            cat heavydb-output.txt
diff --git a/rbc/tests/__init__.py b/rbc/tests/__init__.py
index e3cb9768..d0e54e40 100644
--- a/rbc/tests/__init__.py
+++ b/rbc/tests/__init__.py
@@ -43,7 +43,7 @@ def heavydb_fixture(caller_globals, minimal_version=(0, 0),
        from rbc.tests import heavydb_fixture
 
        @pytest.fixture(scope='module')
-       def omnisci():
+       def heavydb():
            from o in heavydb_fixture(globals()):
                # do some customization here
                yield o
@@ -78,7 +78,7 @@ def require_version(version, message=None, label=None):
         version and the heavydb version match exactly and these
         correspond to the current development version, if the
         specified label does not match with the value of envrinment
-        variable OMNISCIDB_DEV_LABEL, then the corresponing test will
+        variable HEAVYDB_DEV_LABEL, then the corresponing test will
         be skipped. Use label 'docker-dev' when using heavydb dev
         docker image.
 
@@ -126,7 +126,7 @@ def require_version(version, message=None, label=None):
             pytest.skip(_reason)
 
         if label is not None:
-            env_label = os.environ.get('OMNISCIDB_DEV_LABEL')
+            env_label = os.environ.get('HEAVYDB_DEV_LABEL')
             if env_label and label == 'docker-dev':
                 # docker-dev is some older master, so it must work
                 # with the current master as well as with branches based on the current master.
@@ -138,7 +138,7 @@ def require_version(version, message=None, label=None):
                 # master.
                 label = env_label
             if env_label is None:
-                warnings.warn('Environment does not specify label (OMNISCIDB_DEV_LABEL is unset).'
+                warnings.warn('Environment does not specify label (HEAVYDB_DEV_LABEL is unset).'
                               ' Tests with development labels will not be run.')
             if env_label != label:
                 _reason = (f'test requires version {version} with label {label},'
diff --git a/rbc/tests/heavyai/test_array.py b/rbc/tests/heavyai/test_array.py
index 15931b7b..48cc2be3 100644
--- a/rbc/tests/heavyai/test_array.py
+++ b/rbc/tests/heavyai/test_array.py
@@ -2,7 +2,7 @@
 from collections import defaultdict
 
 from rbc.heavyai import Array
-from rbc.errors import OmnisciServerError
+from rbc.errors import HeavyDBServerError
 from rbc.stdlib import array_api
 from numba import types as nb_types
 from numba import TypingError
@@ -462,7 +462,7 @@ def issue77():
         _, result = heavydb.sql_execute('select issue77();')
         assert list(result)[0][0] == [1, 1, 1, 1, 1]
     else:
-        with pytest.raises(OmnisciServerError) as exc:
+        with pytest.raises(HeavyDBServerError) as exc:
             _, result = heavydb.sql_execute('select issue77();')
 
         assert exc.match('Could not bind issue77()')
diff --git a/rbc/tests/heavyai/test_caller.py b/rbc/tests/heavyai/test_caller.py
index e6ee6e07..97d05f35 100644
--- a/rbc/tests/heavyai/test_caller.py
+++ b/rbc/tests/heavyai/test_caller.py
@@ -56,11 +56,11 @@ def test_udf_string_repr(heavydb):
     assert_equal(str(myincr), "myincr['T(T), T=int32|int64|float32|float64']")
 
     assert_equal(repr(myincr(5)),
-                 "OmnisciQueryCapsule('SELECT myincr(CAST(5 AS BIGINT))')")
+                 "HeavyDBQueryCapsule('SELECT myincr(CAST(5 AS BIGINT))')")
     assert_equal(str(myincr(5)), "SELECT myincr(CAST(5 AS BIGINT))")
 
     assert_equal(repr(myincr(myincr(5))),
-                 "OmnisciQueryCapsule('SELECT myincr(CAST(myincr(CAST(5 AS BIGINT)) AS BIGINT))')")
+                 "HeavyDBQueryCapsule('SELECT myincr(CAST(myincr(CAST(5 AS BIGINT)) AS BIGINT))')")
     assert_equal(str(myincr(myincr(5))),
                  "SELECT myincr(CAST(myincr(CAST(5 AS BIGINT)) AS BIGINT))")
 
@@ -76,7 +76,7 @@ def test_udtf_string_repr(heavydb):
                   " T=int64|float64|int32, device=cpu']"))
 
     assert_equal(repr(arange(5, 0)),
-                 ("OmnisciQueryCapsule('SELECT x FROM"
+                 ("HeavyDBQueryCapsule('SELECT x FROM"
                   " TABLE(arange(CAST(5 AS INT), CAST(0 AS BIGINT)))')"))
     assert_equal(str(arange(5, 0)),
                  "SELECT x FROM TABLE(arange(CAST(5 AS INT), CAST(0 AS BIGINT)))")
diff --git a/rbc/tests/heavyai/test_device_selection.py b/rbc/tests/heavyai/test_device_selection.py
index 02dc33cd..aaa7007e 100644
--- a/rbc/tests/heavyai/test_device_selection.py
+++ b/rbc/tests/heavyai/test_device_selection.py
@@ -212,7 +212,7 @@ def test_device_selection_pair(heavydb, func12, ext, kind2, kind1):
     if 'udtf' in ext and kind1 == 'lt':
         pytest.skip('Load-time UDTFs not supported')
 
-    # Omniscidb server option --allow-query-step-cpu-retry=1 was
+    # HeavyDB server option --allow-query-step-cpu-retry=1 was
     # introduced in heavydb-internal PR 5798, here assuming the
     # default value.
     allow_query_step_cpu_retry = heavydb.version[:2] >= (5, 8)
diff --git a/rbc/tests/heavyai/test_heavyai.py b/rbc/tests/heavyai/test_heavyai.py
index 41aac6c4..84d54b9a 100644
--- a/rbc/tests/heavyai/test_heavyai.py
+++ b/rbc/tests/heavyai/test_heavyai.py
@@ -3,7 +3,7 @@
 import pytest
 import numpy as np
 
-from rbc.errors import UnsupportedError, OmnisciServerError
+from rbc.errors import UnsupportedError, HeavyDBServerError
 from rbc.tests import heavydb_fixture, assert_equal
 from rbc.typesystem import Type
 
@@ -753,7 +753,7 @@ def fahrenheit2celsius(f):
     heavydb.unregister()
 
     msg = "Undefined function call"
-    with pytest.raises(OmnisciServerError, match=msg):
+    with pytest.raises(HeavyDBServerError, match=msg):
         heavydb.sql_execute('select fahrenheit2celsius(40)')
 
 
diff --git a/rbc/tests/heavyai/test_mlpack.py b/rbc/tests/heavyai/test_mlpack.py
index c7a73aa7..9ef940b5 100644
--- a/rbc/tests/heavyai/test_mlpack.py
+++ b/rbc/tests/heavyai/test_mlpack.py
@@ -1,7 +1,7 @@
 import pytest
 import re
 from rbc.tests import heavydb_fixture
-from rbc.errors import OmnisciServerError
+from rbc.errors import HeavyDBServerError
 
 
 @pytest.fixture(scope='module')
@@ -24,7 +24,7 @@ def test_mlpack(heavydb, func):
 
     try:
         _, result = heavydb.sql_execute(query)
-    except OmnisciServerError as msg:
+    except HeavyDBServerError as msg:
         m = re.match(fr'.*Undefined function call {func!r}',
                      msg.args[0])
         if m is not None:
diff --git a/rbc/tests/test_ci.py b/rbc/tests/test_ci.py
index b403a5bb..4ca62ffa 100644
--- a/rbc/tests/test_ci.py
+++ b/rbc/tests/test_ci.py
@@ -27,11 +27,11 @@ def test_python_version():
 
 
 def test_heavydb_version(heavydb):
-    varname = 'EXPECTED_OMNISCIDB_VERSION'
+    varname = 'EXPECTED_HEAVYDB_VERSION'
     current = heavydb.version
     expected = os.environ.get(varname)
     if 'CI' in os.environ and expected is None:
-        pytest.fail("OmniSciDB server is not running")
+        pytest.fail("HeavyDB server is not running")
     if expected is None:
         pytest.skip(
             f'Undefined environment variable {varname},'