java-modeling_using_maps.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "complete-language",
   "metadata": {},
   "source": [
    "# Modeling Using Maps\n",
    "*Last updated: August 6, 2021*\n",
    "\n",
    "This notebook shares how Aerospike facilitates working with map data, covering the following topics:\n",
    "\n",
    "1. Ordering\n",
    "2. Index & Rank\n",
    "3. Nested Structures (subcontexts)\n",
    "\n",
    "The above Aerospike Map capabilities provide significant utility through providing easy and precise control and access to map data. This notebook shares how to incorporate these strengths and best practices, and use Maps as a powerful modeling tool.\n",
    "\n",
    "This [Jupyter Notebook](https://jupyter-notebook.readthedocs.io/en/stable/notebook.html) requires the Aerospike Database running locally with Java kernel and Aerospike Java Client. To create a Docker container that satisfies the requirements and holds a copy of these notebooks, visit the [Aerospike Notebooks Repo](https://github.com/aerospike-examples/interactive-notebooks)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unsigned-commissioner",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Notebook Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "right-eligibility",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Import Jupyter Java Integration "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "secondary-sally",
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import io.github.spencerpark.ijava.IJava;\n",
    "import io.github.spencerpark.jupyter.kernel.magic.common.Shell;\n",
    "\n",
    "IJava.getKernelInstance().getMagics().registerMagics(Shell.class);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "conventional-smith",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Start Aerospike"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "parliamentary-liberia",
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "%sh asd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "specialized-score",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Download the Aerospike Java Client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "defensive-democracy",
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "%%loadFromPOM\n",
    "<dependencies>\n",
    "  <dependency>\n",
    "    <groupId>com.aerospike</groupId>\n",
    "    <artifactId>aerospike-client</artifactId>\n",
    "    <version>5.0.0</version>\n",
    "  </dependency>\n",
    "</dependencies>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "athletic-farmer",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Start the Aerospike Java Client and Connect\n",
    "\n",
    "The default cluster location for the Docker container is *localhost* port *3000*. If your cluster is not running on your local machine, modify *localhost* and *3000* to the values for your Aerospike cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "tamil-score",
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialized the client and connected to the cluster.\n"
     ]
    }
   ],
   "source": [
    "import com.aerospike.client.AerospikeClient;\n",
    "\n",
    "AerospikeClient client = new AerospikeClient(\"localhost\", 3000);\n",
    "System.out.println(\"Initialized the client and connected to the cluster.\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dated-raise",
   "metadata": {},
   "source": [
    "# Prerequisites\n",
    "\n",
    "* [Reading and Updating Maps](./java-working_with_maps.ipynb)\n",
    "* [Advanced Collection Data Types](./java-advanced_collection_data_types.ipynb)\n",
    "* [Introduction to Data Modeling](./java-intro_to_data_modeling.ipynb)\n",
    "* [Modeling Using Lists](./java-modeling_using_lists.ipynb)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "intellectual-aaron",
   "metadata": {},
   "source": [
    "# Aerospike Provides Powerful Resources for Working with Document-Oriented Data \n",
    "\n",
    "Aerospike is a real-time data platform architected to store Document-Oriented Data efficiently at scale. Rather than a traditional KVS approach of blindly storing blobs in the database and sorting the data in the application, Aerospike provides rich Map and List (Collection Data Type) APIs for operating on Aerospike Records. The result is that rather than spending an outsized time packing, unpacking, and transporting data to and from the database, significant performance efficiencies are gained by working with Document-Oriented Data on the server-side."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "radical-grill",
   "metadata": {},
   "source": [
    "# Apply Key-Order or Key/Value-Order to Maps\n",
    "\n",
    "The default order for Aerospike Maps is unordered. The best practice is to use an ordered map, either Key-ordered (K-ordered) or Key/Value-ordered (KV-ordered):\n",
    "* If the application reads data only by-key, use K-ordered.\n",
    "* If the application reads data frequently by either by-value or by-rank operations, use KV-ordered.\n",
    "\n",
    "Worst case [Map Operation Performance](https://docs.aerospike.com/docs/guide/cdt-map-performance.html) highlight that the benefits of operating on a pre-sorted list are significant."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "worth-junction",
   "metadata": {},
   "source": [
    "## Ordering Example\n",
    "\n",
    "Add map keys ```(b=0, z=2, c=9, a=1, yy=1)``` to Bins containing unordered, K-ordered, and KV-ordered maps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "seeing-racing",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The unordered map is: {yy=1, a=1, b=0, z=2, c=9}\n",
      "The k-ordered map is: {a=1, b=0, c=9, yy=1, z=2}\n",
      "The kv-unordered map is also: {a=1, b=0, c=9, yy=1, z=2}\n"
     ]
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "import java.util.Arrays;\n",
    "import java.util.HashMap;\n",
    "import java.util.List;\n",
    "import java.util.Map;\n",
    "import com.aerospike.client.Key;\n",
    "import com.aerospike.client.Bin;\n",
    "import com.aerospike.client.Record;\n",
    "import com.aerospike.client.Operation;\n",
    "import com.aerospike.client.Value;\n",
    "import com.aerospike.client.cdt.MapOperation;\n",
    "import com.aerospike.client.cdt.MapOrder;\n",
    "import com.aerospike.client.cdt.MapPolicy;\n",
    "import com.aerospike.client.cdt.MapWriteFlags;\n",
    "\n",
    "\n",
    "String mapModelSetName = \"mapmodelset1\";\n",
    "String mapModelNamespaceName = \"test\";\n",
    "\n",
    "String mapOrderKeyName = \"mapOrder\";\n",
    "Key mapOrderKey = new Key(mapModelNamespaceName, mapModelSetName, mapOrderKeyName);\n",
    "\n",
    "String unorderedMapBinName = \"uoBin\";\n",
    "String kOrderedMapBinName = \"koBin\";\n",
    "String kvOrderedMapBinName = \"kvoBin\";\n",
    "\n",
    "Bin bin1 = new Bin(unorderedMapBinName, mapOrderKeyName);\n",
    "Bin bin2 = new Bin(kOrderedMapBinName, mapOrderKeyName);\n",
    "Bin bin3 = new Bin(kvOrderedMapBinName, mapOrderKeyName);\n",
    "\n",
    "MapPolicy unorderedBinPolicy = new MapPolicy();\n",
    "MapPolicy kOrderedBinPolicy = new MapPolicy(MapOrder.KEY_ORDERED, MapWriteFlags.DEFAULT);\n",
    "MapPolicy kvOrderedBinPolicy = new MapPolicy(MapOrder.KEY_VALUE_ORDERED, MapWriteFlags.DEFAULT);\n",
    "\n",
    "\n",
    "String stringKey0 = \"b\";\n",
    "Integer intValue0 = 0;\n",
    "String stringKey1 = \"z\";\n",
    "Integer intValue1 = 2;\n",
    "String stringKey2 = \"c\";\n",
    "Integer intValue2 = 9;\n",
    "String stringKey3 = \"a\";\n",
    "Integer intValue3 = 1;\n",
    "String stringKey4 = \"yy\";\n",
    "Integer intValue4 = 1;\n",
    "\n",
    "\n",
    "Record addMapKeys = client.operate(null, mapOrderKey,\n",
    "    MapOperation.put(unorderedBinPolicy, unorderedMapBinName, Value.get(stringKey0), Value.get(intValue0)), \n",
    "    MapOperation.put(kOrderedBinPolicy, kOrderedMapBinName, Value.get(stringKey0), Value.get(intValue0)), \n",
    "    MapOperation.put(kvOrderedBinPolicy, kvOrderedMapBinName, Value.get(stringKey0), Value.get(intValue0)), \n",
    "    MapOperation.put(unorderedBinPolicy, unorderedMapBinName, Value.get(stringKey1), Value.get(intValue1)), \n",
    "    MapOperation.put(kOrderedBinPolicy, kOrderedMapBinName, Value.get(stringKey1), Value.get(intValue1)), \n",
    "    MapOperation.put(kvOrderedBinPolicy, kvOrderedMapBinName, Value.get(stringKey1), Value.get(intValue1)), \n",
    "    MapOperation.put(unorderedBinPolicy, unorderedMapBinName, Value.get(stringKey2), Value.get(intValue2)), \n",
    "    MapOperation.put(kOrderedBinPolicy, kOrderedMapBinName, Value.get(stringKey2), Value.get(intValue2)), \n",
    "    MapOperation.put(kvOrderedBinPolicy, kvOrderedMapBinName, Value.get(stringKey2), Value.get(intValue2)), \n",
    "    MapOperation.put(unorderedBinPolicy, unorderedMapBinName, Value.get(stringKey3), Value.get(intValue3)), \n",
    "    MapOperation.put(kOrderedBinPolicy, kOrderedMapBinName, Value.get(stringKey3), Value.get(intValue3)), \n",
    "    MapOperation.put(kvOrderedBinPolicy, kvOrderedMapBinName, Value.get(stringKey3), Value.get(intValue3)), \n",
    "    MapOperation.put(unorderedBinPolicy, unorderedMapBinName, Value.get(stringKey4), Value.get(intValue4)), \n",
    "    MapOperation.put(kOrderedBinPolicy, kOrderedMapBinName, Value.get(stringKey4), Value.get(intValue4)), \n",
    "    MapOperation.put(kvOrderedBinPolicy, kvOrderedMapBinName, Value.get(stringKey4), Value.get(intValue4)) \n",
    "    );\n",
    "Record outMaps = client.get(null, mapOrderKey);\n",
    "\n",
    "\n",
    "System.out.println(\"The unordered map is: \" + outMaps.getValue(unorderedMapBinName));\n",
    "System.out.println(\"The k-ordered map is: \" + outMaps.getValue(kOrderedMapBinName));\n",
    "System.out.println(\"The kv-unordered map is also: \" + outMaps.getValue(kvOrderedMapBinName));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "annoying-approval",
   "metadata": {},
   "source": [
    "**Note:** As demonstrated above, using unordered Maps in Aerospike will not preserve insertion order. If insertion order is relevant to the application, consider the following options:\n",
    "* Appending Maps to an Unordered List \n",
    "* Storing insertion order or a timestamp-like field in your Map "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "traditional-consensus",
   "metadata": {},
   "source": [
    "# Map Index and Rank\n",
    "\n",
    "In Aerospike, **Map Index** operations provide data in the key order. \n",
    "\n",
    "**Map Rank** operations provides data in order of the value. Aerospike provides a methodical order for maps, the following are factors that impact rank:\n",
    "1. Higher number of elements in the Map means higher rank.\n",
    "2. For maps with the same number of elements, compare the KV-sorted list.\n",
    "   * Higher key results in higher rank.\n",
    "   * Same key and higher value results in higher rank.\n",
    "   \n",
    "**Note:** Aerospike's range operations for Index, Rank, and Value are powerful, though not used here. See [Modeling Using Lists](./java-modeling_using_lists.ipynb) or [Reading and Updating Maps](./java-working_with_maps.ipynb) for examples."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "weighted-dayton",
   "metadata": {},
   "source": [
    "## Index and Rank Examples\n",
    "\n",
    "The following example shows index and rank operations using a list of maps."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "improved-hawaii",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### Create List of Maps Example Data\n",
    "\n",
    "```[\n",
    "   {z=26}\n",
    "   {a=1, b=2}\n",
    "   {e=5, a=1, b=2, c=3}\n",
    "   {c=3, b=2}\n",
    "   {b=2, c=3}\n",
    "   {a=1}\n",
    "]```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "equivalent-bridges",
   "metadata": {
    "hidden": true,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The data is: [{z=26}, {a=1, b=2}, {a=1, b=2, c=3, e=5}, {b=2, c=3}, {b=2, c=3}, {a=1}]\n"
     ]
    }
   ],
   "source": [
    "import com.aerospike.client.cdt.ListOperation;\n",
    "import com.aerospike.client.cdt.ListOrder;\n",
    "import com.aerospike.client.cdt.ListPolicy;\n",
    "import com.aerospike.client.cdt.ListWriteFlags;\n",
    "import com.aerospike.client.cdt.ListReturnType;\n",
    "import com.aerospike.client.cdt.MapReturnType;\n",
    "import com.aerospike.client.cdt.CTX;\n",
    "\n",
    "\n",
    "String stringKey0 = \"z\";\n",
    "Integer intValue0 = 26;\n",
    "String stringKey1 = \"a\";\n",
    "Integer intValue1 = 1;\n",
    "String stringKey2 = \"b\";\n",
    "Integer intValue2 = 2;\n",
    "String stringKey3 = \"c\";\n",
    "Integer intValue3 = 3;\n",
    "String stringKey4 = \"e\";\n",
    "Integer intValue4 = 5;\n",
    "\n",
    "\n",
    "String mapIndexAndRankKeyName = \"mapIndexAndRank\";\n",
    "Key mapIndexAndRankKey = new Key(mapModelNamespaceName, mapModelSetName, mapIndexAndRankKeyName);\n",
    "\n",
    "String unorderedListBinName = \"uoListBin\";\n",
    "\n",
    "Bin bin1 = new Bin(unorderedListBinName, mapIndexAndRankKeyName);\n",
    "\n",
    "Record addMapKeys = client.operate(null, mapIndexAndRankKey,\n",
    "    ListOperation.clear(unorderedListBinName),\n",
    "    ListOperation.create(unorderedListBinName, ListOrder.UNORDERED, false),\n",
    "    MapOperation.create(unorderedListBinName, MapOrder.UNORDERED, CTX.listIndexCreate(0, ListOrder.UNORDERED, false)),\n",
    "    MapOperation.put(unorderedBinPolicy, unorderedListBinName, Value.get(stringKey0), Value.get(intValue0), CTX.listIndex(0)),\n",
    "    MapOperation.create(unorderedListBinName, MapOrder.UNORDERED, CTX.listIndexCreate(1, ListOrder.UNORDERED, false)),    \n",
    "    MapOperation.put(unorderedBinPolicy, unorderedListBinName, Value.get(stringKey1), Value.get(intValue1), CTX.listIndex(1)),\n",
    "    MapOperation.put(unorderedBinPolicy, unorderedListBinName, Value.get(stringKey2), Value.get(intValue2), CTX.listIndex(1)),\n",
    "    MapOperation.create(unorderedListBinName, MapOrder.UNORDERED, CTX.listIndexCreate(2, ListOrder.UNORDERED, false)),    \n",
    "    MapOperation.put(unorderedBinPolicy, unorderedListBinName, Value.get(stringKey4), Value.get(intValue4), CTX.listIndex(2)),\n",
    "    MapOperation.put(unorderedBinPolicy, unorderedListBinName, Value.get(stringKey1), Value.get(intValue1), CTX.listIndex(2)),\n",
    "    MapOperation.put(unorderedBinPolicy, unorderedListBinName, Value.get(stringKey2), Value.get(intValue2), CTX.listIndex(2)),\n",
    "    MapOperation.put(unorderedBinPolicy, unorderedListBinName, Value.get(stringKey3), Value.get(intValue3), CTX.listIndex(2)),\n",
    "    MapOperation.create(unorderedListBinName, MapOrder.UNORDERED, CTX.listIndexCreate(3, ListOrder.UNORDERED, false)),\n",
    "    MapOperation.put(unorderedBinPolicy, unorderedListBinName, Value.get(stringKey3), Value.get(intValue3), CTX.listIndex(3)),\n",
    "    MapOperation.put(unorderedBinPolicy, unorderedListBinName, Value.get(stringKey2), Value.get(intValue2), CTX.listIndex(3)),\n",
    "    MapOperation.create(unorderedListBinName, MapOrder.UNORDERED, CTX.listIndexCreate(4, ListOrder.UNORDERED, false)),\n",
    "    MapOperation.put(unorderedBinPolicy, unorderedListBinName, Value.get(stringKey2), Value.get(intValue2), CTX.listIndex(4)),\n",
    "    MapOperation.put(unorderedBinPolicy, unorderedListBinName, Value.get(stringKey3), Value.get(intValue3), CTX.listIndex(4)),\n",
    "    MapOperation.create(unorderedListBinName, MapOrder.UNORDERED, CTX.listIndexCreate(5, ListOrder.UNORDERED, false)),\n",
    "    MapOperation.put(unorderedBinPolicy, unorderedListBinName, Value.get(stringKey1), Value.get(intValue1), CTX.listIndex(5))\n",
    "    );\n",
    "Record listOfMaps = client.get(null, mapIndexAndRankKey);\n",
    "\n",
    "System.out.println(\"The data is: \" + listOfMaps.getValue(unorderedListBinName));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "approximate-search",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**Note:** This was explicitly written longform to not hide any important knowledge in Java code complexity. Most developers would create a Java TreeMap and use putItems to put the map in Aerospike.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "actual-counter",
   "metadata": {},
   "source": [
    "### Use Index and Rank"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "worse-smile",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first element by index in the 3rd map in the list is:[a=1]\n",
      "The maps in order from highest to lowest rank is: [{a=1, b=2, c=3, e=5}, {b=2, c=3}, {b=2, c=3}, {a=1, b=2}, {z=26}, {a=1}]\n"
     ]
    }
   ],
   "source": [
    "Record getIndexAndRank = client.operate(null, mapIndexAndRankKey,\n",
    "    MapOperation.getByIndex(unorderedListBinName, 0, MapReturnType.KEY_VALUE, CTX.listIndex(2)),\n",
    "    ListOperation.getByRankRange(unorderedListBinName, 0, 6, ListReturnType.VALUE)\n",
    "    );\n",
    "\n",
    "List<?> indexAndRankResults = getIndexAndRank.getList(unorderedListBinName);\n",
    "System.out.println(\"The first element by index in the 3rd map in the list is:\" + indexAndRankResults.get(0));\n",
    "System.out.println(\"The maps in order from highest to lowest rank is: \" + indexAndRankResults.get(1));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "decent-gardening",
   "metadata": {},
   "source": [
    "# Distinguishing Maps from Bins\n",
    "\n",
    "It is important to highlight how an Aerospike Map (in a Bin) differs from a Bin."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "neural-profession",
   "metadata": {},
   "source": [
    "## Unique Properties of Aerospike Bins\n",
    "\n",
    "Bins were architected with the following design constraints:\n",
    "* A Namespace can contain a maximum of 32k-1 unique Bin names. This was increased to 64k-1 in Aerospike Database 5.0+.\n",
    "* A Record can contain up to 32k-1 Bins.\n",
    "* Bins names are limited to 15 characters and are stored unencoded.\n",
    "* Bins have higher metadata overhead than Maps."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "instrumental-pitch",
   "metadata": {},
   "source": [
    "## Unique Properties of Maps\n",
    "\n",
    "Maps were architected for the flexibility needed from the data type."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "literary-australian",
   "metadata": {},
   "source": [
    "### Storage Efficiency\n",
    "By comparison, Aerospike Maps use [MessagePack Serialization](https://msgpack.org/index.html), to compress and index a map's keys and values. This makes storing and working with large maps quite efficient. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "british-excess",
   "metadata": {},
   "source": [
    "### Setting Context to Operations\n",
    "\n",
    "Aerospike Database supports arbitrarily deep nesting within Container Data Types (CDTs), Lists and Maps. As an application adds data to a Map in Aerospike, the application also creates indexes and subindexes, which allow operations to supply an operation with the precise context of the data to be operated on. By understanding the nested structure of a Map, an application can efficiently apply operations to the appropriate context within a Map and send only the relevant parts of a Map across the wire back to the client. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "molecular-victor",
   "metadata": {},
   "source": [
    "## Bins or Maps: Best Practice for Modeling\n",
    "\n",
    "Based on the above constraints, the best practices for longterm Aerospike use are:\n",
    "1. When storing data in Bins, use *and reuse* fewer, shorter, consistent Bin names.\n",
    "2. Use Maps with arbitrary nesting widely."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "taken-activity",
   "metadata": {},
   "source": [
    "## Map Index, Rank, and Context Example\n",
    "\n",
    "A credit card user can have multiple credit cards. This is modeled as:\n",
    "* A User: Bin containing a K-ordered map  \n",
    "   * Cards: Mapkey whose value is an Unordered list  \n",
    "      * A Card: KV-ordered map"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "subtle-chosen",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### Create Credit Card Model Data\n",
    "\n",
    "```user:\n",
    "   { \n",
    "   \"cards\" = \n",
    "      [\n",
    "         { \n",
    "            \"last_six\" = 51111\n",
    "            \"expires\" = 202201\n",
    "            \"cvv\" = 111\n",
    "            \"zip\" = 95008\n",
    "            \"default\" = 1\n",
    "         }\n",
    "      ]\n",
    "   }```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "better-eugene",
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Credit Card data is: {cards=[{cvv=111, default=1, expires=202201, last_six=511111, zip=95008}]}\n"
     ]
    }
   ],
   "source": [
    "import java.util.List;\n",
    "import java.util.Map;\n",
    "\n",
    "String cardsMapKey = \"cards\";    \n",
    "List<String> emptyCardsList = Collections.<String>emptyList();\n",
    "\n",
    "String cardMapKeyLast6 = \"last_six\";\n",
    "String cardMapKeyExp = \"expires\";\n",
    "String cardMapKeyCVV = \"cvv\";\n",
    "String cardMapKeyZip = \"zip\";\n",
    "String cardMapKeyDefault = \"default\";\n",
    "\n",
    "\n",
    "Integer cardValue1Last6 = 511111;\n",
    "Integer cardValue1Exp = 202201;\n",
    "Integer cardValue1CVV = 111;\n",
    "Integer cardValue1Zip = 95008;\n",
    "Integer cardValueDefault = 1;\n",
    "\n",
    "\n",
    "String mapCreditCardKeyName = \"mapCreditCard\";\n",
    "Key mapCreditCardKey = new Key(mapModelNamespaceName, mapModelSetName, mapCreditCardKeyName);\n",
    "\n",
    "Bin bin1 = new Bin(kOrderedMapBinName, mapCreditCardKeyName);\n",
    "\n",
    "Record createUserAndAddCC1 = client.operate(null, mapCreditCardKey,\n",
    "    MapOperation.clear(kOrderedMapBinName),\n",
    "    MapOperation.put(kOrderedBinPolicy, kOrderedMapBinName, Value.get(cardsMapKey), Value.get(emptyCardsList)),\n",
    "    MapOperation.create(kOrderedMapBinName, MapOrder.KEY_VALUE_ORDERED, CTX.mapKey(Value.get(cardsMapKey)), CTX.listIndexCreate(0, ListOrder.UNORDERED, false)),\n",
    "    MapOperation.put(kvOrderedBinPolicy, kOrderedMapBinName, Value.get(cardMapKeyLast6), Value.get(cardValue1Last6), CTX.mapKey(Value.get(cardsMapKey)), CTX.listIndex(0)),\n",
    "    MapOperation.put(kvOrderedBinPolicy, kOrderedMapBinName, Value.get(cardMapKeyExp), Value.get(cardValue1Exp), CTX.mapKey(Value.get(cardsMapKey)), CTX.listIndex(0)),\n",
    "    MapOperation.put(kvOrderedBinPolicy, kOrderedMapBinName, Value.get(cardMapKeyCVV), Value.get(cardValue1CVV), CTX.mapKey(Value.get(cardsMapKey)), CTX.listIndex(0)),\n",
    "    MapOperation.put(kvOrderedBinPolicy, kOrderedMapBinName, Value.get(cardMapKeyZip), Value.get(cardValue1Zip), CTX.mapKey(Value.get(cardsMapKey)), CTX.listIndex(0)),\n",
    "    MapOperation.put(kvOrderedBinPolicy, kOrderedMapBinName, Value.get(cardMapKeyDefault), Value.get(cardValueDefault), CTX.mapKey(Value.get(cardsMapKey)), CTX.listIndex(0))\n",
    "    );\n",
    "    \n",
    "Record getCardMap = client.get(null, mapCreditCardKey);\n",
    "System.out.println(\"The Credit Card data is: \" + getCardMap.getValue(kOrderedMapBinName));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "finite-eagle",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**Note:** This was explicitly written longform to not hide any knowledge in Java code complexity. Most developers would create a Java TreeMap and use putItems to put the map in Aerospike.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "knowing-louisiana",
   "metadata": {},
   "source": [
    "### Use Index, Rank, and Contexts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "endless-community",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The default card is: {cvv=111, default=1, expires=202201, last_six=511111, zip=95008}\n",
      "Added new card: {cvv=222, expires=202202, last_six=522222, zip=95008}\n",
      "The default card is still: {cvv=111, default=1, expires=202201, last_six=511111, zip=95008}\n",
      "Changed the default card, the new default is: {cvv=222, default=1, expires=202202, last_six=522222, zip=95008}\n"
     ]
    }
   ],
   "source": [
    "Integer cardValue2Last6 = 522222;\n",
    "Integer cardValue2Exp = 202202;\n",
    "Integer cardValue2CVV = 222;\n",
    "Integer cardValue2Zip = 95008;\n",
    "\n",
    "Record getDefaultCard1 = client.operate(null, mapCreditCardKey,\n",
    "    ListOperation.getByRank(kOrderedMapBinName, -1, ListReturnType.VALUE, CTX.mapKey(Value.get(cardsMapKey)))\n",
    "    );\n",
    "System.out.println(\"The default card is: \" + getDefaultCard1.getValue(kOrderedMapBinName));\n",
    "\n",
    "Record addCC2 = client.operate(null, mapCreditCardKey,\n",
    "    MapOperation.create(kOrderedMapBinName, MapOrder.KEY_VALUE_ORDERED, CTX.mapKey(Value.get(cardsMapKey)), CTX.listIndexCreate(1, ListOrder.UNORDERED, false)),\n",
    "    MapOperation.put(kvOrderedBinPolicy, kOrderedMapBinName, Value.get(cardMapKeyLast6), Value.get(cardValue2Last6), CTX.mapKey(Value.get(cardsMapKey)), CTX.listIndex(1)),\n",
    "    MapOperation.put(kvOrderedBinPolicy, kOrderedMapBinName, Value.get(cardMapKeyExp), Value.get(cardValue2Exp), CTX.mapKey(Value.get(cardsMapKey)), CTX.listIndex(1)),\n",
    "    MapOperation.put(kvOrderedBinPolicy, kOrderedMapBinName, Value.get(cardMapKeyCVV), Value.get(cardValue2CVV), CTX.mapKey(Value.get(cardsMapKey)), CTX.listIndex(1)),\n",
    "    MapOperation.put(kvOrderedBinPolicy, kOrderedMapBinName, Value.get(cardMapKeyZip), Value.get(cardValue2Zip), CTX.mapKey(Value.get(cardsMapKey)), CTX.listIndex(1))\n",
    "    );\n",
    "\n",
    "Record getCard2 = client.operate(null, mapCreditCardKey,\n",
    "    ListOperation.getByIndex(kOrderedMapBinName, 1, ListReturnType.VALUE, CTX.mapKey(Value.get(cardsMapKey)))\n",
    "    );\n",
    "\n",
    "Record getDefaultCard2 = client.operate(null, mapCreditCardKey,\n",
    "    ListOperation.getByRank(kOrderedMapBinName, -1, ListReturnType.VALUE, CTX.mapKey(Value.get(cardsMapKey)))\n",
    "    );\n",
    "\n",
    "Record makeCard2TheDefault = client.operate(null, mapCreditCardKey,\n",
    "    MapOperation.removeByKey(kOrderedMapBinName, Value.get(cardMapKeyDefault), MapReturnType.NONE, CTX.mapKey(Value.get(cardsMapKey)), CTX.listRank(0)),\n",
    "    MapOperation.put(kvOrderedBinPolicy, kOrderedMapBinName, Value.get(cardMapKeyDefault), Value.get(cardValueDefault), CTX.mapKey(Value.get(cardsMapKey)), CTX.listIndex(1))\n",
    "    );\n",
    "\n",
    "Record getDefaultCard3 = client.operate(null, mapCreditCardKey,\n",
    "    ListOperation.getByRank(kOrderedMapBinName, -1, ListReturnType.VALUE, CTX.mapKey(Value.get(cardsMapKey)))\n",
    "    );\n",
    "\n",
    "System.out.println(\"Added new card: \" + getCard2.getValue(kOrderedMapBinName));\n",
    "System.out.println(\"The default card is still: \" + getDefaultCard2.getValue(kOrderedMapBinName));\n",
    "System.out.println(\"Changed the default card, the new default is: \" + getDefaultCard3.getValue(kOrderedMapBinName));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "recreational-praise",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Notebook Cleanup"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "viral-weight",
   "metadata": {
    "hidden": true
   },
   "source": [
    "## Truncate the Set\n",
    "\n",
    "Truncate the set from the Aerospike Database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "automotive-reggae",
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set Truncated.\n"
     ]
    }
   ],
   "source": [
    "import com.aerospike.client.policy.InfoPolicy;\n",
    "InfoPolicy infoPolicy = new InfoPolicy();\n",
    "\n",
    "client.truncate(infoPolicy, mapModelNamespaceName, mapModelSetName, null);\n",
    "System.out.println(\"Set Truncated.\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "seventh-lebanon",
   "metadata": {
    "hidden": true
   },
   "source": [
    "## Close the Connection to Aerospike"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "southern-restaurant",
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Server connection closed.\n"
     ]
    }
   ],
   "source": [
    "client.close();\n",
    "System.out.println(\"Server connection closed.\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "neutral-array",
   "metadata": {},
   "source": [
    "# Takeaways – Maps are Flexible and Powerful\n",
    "\n",
    "Aerospike's Index and Rank methods make Maps powerful. Make sure to K or KV-order the Maps, and take advantage of nesting and contexts."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tracked-smell",
   "metadata": {},
   "source": [
    "## What's Next?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "measured-mainland",
   "metadata": {},
   "source": [
    "### Next Steps\n",
    "\n",
    "Have questions? Don't hesitate to post about modeling using maps on [Aerospike's Discussion Forums](https://discuss.aerospike.com/c/how-developers-are-using-aerospike/data-modeling/143).\n",
    "\n",
    "Want to check out other Java notebooks?\n",
    "1. [Hello, World](./hello_world.ipynb)\n",
    "2. [Aerospike Query and UDF](./query_udf.ipynb)\n",
    "3. [Simple Put Get Example](./SimplePutGetExample.ipynb)\n",
    "4. [Expressions](./expressions.ipynb)\n",
    "5. [Advanced Collection Data Types](./java-advanced_collection_data_types.ipynb)\n",
    "\n",
    "Are you running this from Binder? [Download the Aerospike Notebook Repo](https://github.com/aerospike-examples/interactive-notebooks) and work with Aerospike Database and Jupyter locally using a Docker container."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sorted-decline",
   "metadata": {},
   "source": [
    "## Additional Resources\n",
    "\n",
    "* Want to get started with Java? [Download](https://www.aerospike.com/download/client/) or [install](https://github.com/aerospike/aerospike-client-java) the Aerospike Java Client. \n",
    "* What other ways can we work with Lists? Take a look at [Aerospike's List Operations](https://www.aerospike.com/apidocs/java/com/aerospike/client/cdt/ListOperation.html).\n",
    "* What are Namespaces, Sets, and Bins? Check out the [Aerospike Data Model](https://www.aerospike.com/docs/architecture/data-model.html). \n",
    "* How robust is the Aerospike Database? Browse the [Aerospike Database Architecture](https://www.aerospike.com/docs/architecture/index.html)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "11.0.8+10-LTS"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}