tests.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "restricted-immigration",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "british-pearl",
   "metadata": {},
   "source": [
    "Download if file is not in folder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "weird-depth",
   "metadata": {},
   "outputs": [],
   "source": [
    "from litedict import SQLDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aerial-float",
   "metadata": {},
   "outputs": [],
   "source": [
    "TEST_1 = \"key_test_1\"\n",
    "TEST_2 = \"key_test_2\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "narrative-corpus",
   "metadata": {},
   "source": [
    "Basic functionality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "secure-platinum",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = SQLDict(\":memory:\")\n",
    "\n",
    "d[TEST_1] = \"asdfoobar\"\n",
    "\n",
    "assert d[TEST_1] == \"asdfoobar\"\n",
    "\n",
    "del d[TEST_1]\n",
    "\n",
    "assert d.get(TEST_1, None) is None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "gross-stamp",
   "metadata": {},
   "source": [
    "Glob matching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sixth-consistency",
   "metadata": {},
   "outputs": [],
   "source": [
    "d[TEST_1] = \"asdfoobar\"\n",
    "\n",
    "d[TEST_2] = \"foobarasd\"\n",
    "\n",
    "d[\"key_testx_3\"] = \"barasdfoo\"\n",
    "\n",
    "assert d.glob(\"key_test*\") == [\"asdfoobar\", \"foobarasd\", \"barasdfoo\"]\n",
    "\n",
    "assert d.glob(\"key_test_?\") == [\"asdfoobar\", \"foobarasd\"]\n",
    "\n",
    "assert d.glob(\"key_tes[tx]*\") == [\"asdfoobar\", \"foobarasd\", \"barasdfoo\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "novel-telling",
   "metadata": {},
   "source": [
    "Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "north-equipment",
   "metadata": {},
   "outputs": [],
   "source": [
    "d[TEST_1] = 1\n",
    "\n",
    "d[TEST_2] = 2\n",
    "\n",
    "assert d[TEST_1] + d[TEST_2] == 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "minute-distinction",
   "metadata": {},
   "outputs": [],
   "source": [
    "with d.transaction():\n",
    "    d[\"asd\"] = \"efg\"\n",
    "    d[\"foo\"] = \"bar\"\n",
    "    assert d.conn.in_transaction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aquatic-receiver",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    with d.transaction():\n",
    "        d[\"failed\"] = \"no\"\n",
    "\n",
    "        assert d.conn.in_transaction\n",
    "\n",
    "        raise Exception\n",
    "except:\n",
    "    # check the transaction succesfully rolled back\n",
    "    assert d.get(\"failed\") is None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f5619c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key_testx_3 \"barasdfoo\"\n",
      "key_test_1 1\n",
      "key_test_2 2\n",
      "asd \"efg\"\n",
      "foo \"bar\"\n"
     ]
    }
   ],
   "source": [
    "for k, v in d.items():\n",
    "    print(k, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "991c7fb1",
   "metadata": {},
   "source": [
    "Test moving from/to disk/memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95df7552",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pickle\n",
    "\n",
    "fname = \"test_disk.db\"\n",
    "\n",
    "d = SQLDict(\n",
    "    \":memory:\",\n",
    "    encoder=lambda x: pickle.dumps(x).hex(),\n",
    "    decoder=lambda x: pickle.loads(bytes.fromhex(x)),\n",
    ")\n",
    "\n",
    "d[\"foo\"] = \"bar\"\n",
    "d[\"asd\"] = 2\n",
    "\n",
    "d.to_disk(\"test_disk.db\")\n",
    "\n",
    "assert fname in os.listdir()\n",
    "assert \"foo\" in d\n",
    "assert \"asd\" in d\n",
    "\n",
    "d.close()\n",
    "del d\n",
    "\n",
    "\n",
    "d = SQLDict(\n",
    "    fname,\n",
    "    encoder=lambda x: pickle.dumps(x).hex(),\n",
    "    decoder=lambda x: pickle.loads(bytes.fromhex(x)),\n",
    ")\n",
    "\n",
    "assert d[\"foo\"] == \"bar\"\n",
    "assert d[\"asd\"] == 2\n",
    "\n",
    "d.to_memory()\n",
    "\n",
    "os.unlink(fname)\n",
    "\n",
    "assert d[\"foo\"] == \"bar\"\n",
    "assert d[\"asd\"] == 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "authentic-colon",
   "metadata": {},
   "source": [
    "## Benchmarks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "optional-settle",
   "metadata": {},
   "outputs": [],
   "source": [
    "from string import ascii_lowercase, printable\n",
    "from random import choice\n",
    "import random\n",
    "\n",
    "\n",
    "def random_string(string_length=10, fuzz=False, space=False):\n",
    "    \"\"\"Generate a random string of fixed length \"\"\"\n",
    "    letters = ascii_lowercase\n",
    "    letters = letters + \" \" if space else letters\n",
    "    if fuzz:\n",
    "        letters = printable\n",
    "    return \"\".join(choice(letters) for i in range(string_length))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "devoted-cruise",
   "metadata": {},
   "outputs": [],
   "source": [
    "import gc\n",
    "\n",
    "import pickle\n",
    "\n",
    "import json"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "needed-scope",
   "metadata": {},
   "source": [
    "**Pickle**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sacred-track",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = SQLDict(\n",
    "    \":memory:\",\n",
    "    encoder=lambda x: pickle.dumps(x).hex(),\n",
    "    decoder=lambda x: pickle.loads(bytes.fromhex(x)),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dense-ozone",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "152"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sacred-tennis",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36.8 µs ± 928 ns per loop (mean ± std. dev. of 10 runs, 20,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit -n20000 -r10\n",
    "\n",
    "d[random_string(8)] = random_string(50)\n",
    "\n",
    "d.get(random_string(8), None)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "correct-smith",
   "metadata": {},
   "source": [
    "**Noop**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "imported-university",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = SQLDict(\n",
    "    \":memory:\",\n",
    "    encoder=lambda x: x,\n",
    "    decoder=lambda x: x,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "tutorial-trauma",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bulgarian-colombia",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35 µs ± 941 ns per loop (mean ± std. dev. of 10 runs, 20,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit -n20000 -r10\n",
    "\n",
    "d[random_string(8)] = random_string(50)\n",
    "\n",
    "d.get(random_string(8), None)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hollow-briefs",
   "metadata": {},
   "source": [
    "**JSON**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "frank-stable",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = SQLDict(\n",
    "    \":memory:\",\n",
    "    encoder=lambda x: json.dumps(x),\n",
    "    decoder=lambda x: json.loads(x),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "wooden-enlargement",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "after-essex",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35.9 µs ± 707 ns per loop (mean ± std. dev. of 10 runs, 20,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit -n20000 -r10\n",
    "\n",
    "d[random_string(8)] = random_string(50)\n",
    "\n",
    "d.get(random_string(8), None)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "standard-asian",
   "metadata": {},
   "source": [
    "**Pickle Python obj**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dressed-investor",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = SQLDict(\n",
    "    \":memory:\",\n",
    "    encoder=lambda x: pickle.dumps(x).hex(),\n",
    "    decoder=lambda x: pickle.loads(bytes.fromhex(x)),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sustained-aviation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "technological-filling",
   "metadata": {},
   "outputs": [],
   "source": [
    "class C:\n",
    "    def __init__(self, x):\n",
    "        self.x = x\n",
    "\n",
    "    def pp(self):\n",
    "        return x\n",
    "\n",
    "    def f(self):\n",
    "        def _f(y):\n",
    "            return y * self.x ** 2\n",
    "\n",
    "        return _f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "direct-accent",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20.8 µs ± 574 ns per loop (mean ± std. dev. of 10 runs, 20,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit -n20000 -r10\n",
    "\n",
    "d[random_string(8)] = C(random.randint(1, 200))\n",
    "\n",
    "d.get(random_string(8), None)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "compliant-colony",
   "metadata": {},
   "source": [
    "**Dictionary**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ready-palestine",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "beginning-survey",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "civic-preservation",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26 µs ± 574 ns per loop (mean ± std. dev. of 10 runs, 20,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit -n20000 -r10\n",
    "\n",
    "d[random_string(8)] = random_string(50)\n",
    "\n",
    "d.get(random_string(8), None)"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 5
}