SpringOne2021.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Leap Ahead with Redis 6.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Brian Sam-Bodden\n",
    "\n",
    "- Developer Advocate at Redis\n",
    "- @bsbodden on (Twitter|GitHub|GitLab|LinkedIn)\n",
    "- Technologist\n",
    "- Entrepreneur\n",
    "- Author\n",
    "- Teacher, and Student\n",
    "- Aims to push the envelope of technology and fill the world with better, more passionate programmers.\n",
    "- Brings vision and energy, and willingness to start at the beginning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## DaShaun Carter\n",
    "\n",
    "- 319 days as Partner Solution Architect, Redis\n",
    "- @dashaun on (Twitter|GitHub|GitLab|LinkedIn)\n",
    "- A husband, father of four, volunteer and struggling athlete.\n",
    "- Deliberately practicing to build better software, faster.\n",
    "- Generalist.\n",
    "- Computer Science. MBA.\n",
    "- Continuously learning.\n",
    "- Believes that every rep counts.\n",
    "- Doesn't have anything figured out.\n",
    "- Trying to get a little better every day.\n",
    "- Understanding in order to be understood."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Redis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- The \"Most Loved\" database in StackOverflow's Developer Survey\n",
    "- For the 5th year in a row\n",
    "- Data stored in memory, not on disk\n",
    "- < 1m latency\n",
    "- 162 clients in 50 different languages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Redis OSS 6.2\n",
    "#### The Community Edition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- 6.2 was driven by the community\n",
    "- Loads of community contributed features\n",
    "- 15 new commands\n",
    "- 5 commands changed\n",
    "- 8 commands deprecated"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Spring Data\n",
    "\n",
    "- Data comes in many shapes and flavors\n",
    "- The Spring Data family of project gives you:\n",
    "  - An Java/Spring idiomatic way to access that data\n",
    "  - From low-level constructs...\n",
    "  - To high-level OO abstractions... Reactive/Non-Reactive/Functional-ish\n",
    "  - Object-Mapping and Data Repositories\n",
    "- Learn more at https://spring.io/projects/spring-data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Spring Data Redis (SDR)\n",
    "\n",
    "- Part of the Spring Data Family\n",
    "- Provides easy configuration and access to Redis\n",
    "- Low-level connectivity via Lettuce & Jedis libraries\n",
    "- RedisTemplate(s): High-level abstractions for Redis Ops\n",
    "- Implements Key-Value Mapping/Repositories\n",
    "- Learn more at https://spring.io/projects/spring-data-redis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### String : ValueOperations\n",
    "\n",
    "SET -> set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n"
     ]
    }
   ],
   "source": [
    "redis-cli set leapaheadkey leapaheadvalue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```java\n",
    "@Component\n",
    "public class Set implements Function<Map<String,String>, String> {\n",
    "    private final StringRedisTemplate redisTemplate;\n",
    "\n",
    "    public Set(StringRedisTemplate redisTemplate) {\n",
    "        this.redisTemplate = redisTemplate;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public String apply(Map<String,String> input) {\n",
    "        redisTemplate\n",
    "                .opsForValue()\n",
    "                .set(input.get(\"key\"), input.get(\"value\"));\n",
    "        return \"OK\";\n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK"
     ]
    }
   ],
   "source": [
    "curl -H \"Content-Type: application/json\" localhost:8080/set -d '{\"key\":\"leapahead-string\",\"value\":\"Spring Cloud Function\"}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### String\n",
    "\n",
    "GET -> get"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"leapaheadvalue\"\n"
     ]
    }
   ],
   "source": [
    "redis-cli get leapaheadkey"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```java\n",
    "@Component\n",
    "class Get implements Function<String, String> {\n",
    "\tprivate final StringRedisTemplate redisTemplate;\n",
    "\tpublic ValueGet(StringRedisTemplate redisTemplate){\n",
    "\t\tthis.redisTemplate = redisTemplate;\n",
    "\t}\n",
    "\t@Override\n",
    "\tpublic String apply(String input) {\n",
    "\t\treturn redisTemplate.opsForValue().get(input);\n",
    "\t}\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "leapaheadvalue"
     ]
    }
   ],
   "source": [
    "curl -H \"Content-Type: text/plain\" localhost:8080/get -d 'leapaheadkey'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### String : ValueOperations\n",
    "\n",
    "GETSET -> getAndSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "\"leapaheadvalue\"\n",
      "\"leapaheadvalue\"\n",
      "\"updatedvalue\"\n",
      "\"anotherupdatedvalue\"\n"
     ]
    }
   ],
   "source": [
    "redis-cli set leapaheadkey leapaheadvalue\n",
    "redis-cli get leapaheadkey\n",
    "redis-cli getset leapaheadkey updatedvalue\n",
    "redis-cli getset leapaheadkey anotherupdatedvalue\n",
    "redis-cli get leapaheadkey"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```java\n",
    "@Component\n",
    "public class GetAndSet implements Function<Map<String,String>, String> {\n",
    "    private final StringRedisTemplate redisTemplate;\n",
    "\n",
    "    public GetAndSet(StringRedisTemplate redisTemplate) {\n",
    "        this.redisTemplate = redisTemplate;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public String apply(Map<String,String> input) {\n",
    "        return redisTemplate\n",
    "                .opsForValue()\n",
    "                .getAndSet(input.get(\"key\"), input.get(\"value\"));\n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "Spring Cloud Function\n",
      "This is so cool!  Shout out to Mark Paluch!!!!"
     ]
    }
   ],
   "source": [
    "curl -H \"Content-Type: application/json\" localhost:8080/set -d '{\"key\":\"leapahead-string\",\"value\":\"Spring Cloud Function\"}'\n",
    "echo ''\n",
    "curl -H \"Content-Type: application/json\" localhost:8080/getAndSet -d '{\"key\":\"leapahead-string\",\"value\":\"This is so cool!  Shout out to Mark Paluch!!!!\"}'\n",
    "echo ''\n",
    "curl -H \"Content-Type: text/plain\" localhost:8080/get -d 'leapahead-string'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### String : ValueOperations\n",
    "\n",
    "GETEX -> getAndExpire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "\"This message should self destruct in 3 seconds\"\n",
      "(integer) 2\n",
      "(nil)\n"
     ]
    }
   ],
   "source": [
    "redis-cli set leapaheadkey 'This message should self destruct in 3 seconds'\n",
    "redis-cli getex leapaheadkey ex 3\n",
    "sleep 1\n",
    "redis-cli ttl leapaheadkey\n",
    "sleep 2\n",
    "redis-cli get leapaheadkey"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```java\n",
    "@Component\n",
    "public class GetEx implements Function<Map<String,String>, String> {\n",
    "    private final StringRedisTemplate redisTemplate;\n",
    "\n",
    "    public GetEx(StringRedisTemplate redisTemplate) {\n",
    "        this.redisTemplate = redisTemplate;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public String apply(Map<String,String> input) {\n",
    "        Duration t = Duration.ofSeconds(Long.parseLong(input.get(\"value\")));\n",
    "        return redisTemplate\n",
    "                .opsForValue()\n",
    "                .getAndExpire(input.get(\"key\"), t);\n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "Self-Destructing in 3 seconds\n",
      "(Sleeping for 3 seconds)\n",
      "{\"timestamp\":\"2021-09-02T20:15:09.300+00:00\",\"path\":\"/get\",\"status\":500,\"error\":\"Internal Server Error\",\"requestId\":\"e36c6a60-1\"}"
     ]
    }
   ],
   "source": [
    "curl -H \"Content-Type: application/json\" localhost:8080/set -d '{\"key\":\"leapahead-string\",\"value\":\"Self-Destructing in 3 seconds\"}'\n",
    "echo ''\n",
    "curl -H \"Content-Type: application/json\" localhost:8080/getEx -d '{\"key\":\"leapahead-string\",\"value\":\"3\"}'\n",
    "echo ''\n",
    "echo '(Sleeping for 3 seconds)'\n",
    "sleep 3\n",
    "curl -H \"Content-Type: text/plain\" localhost:8080/get -d 'leapahead-string'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### String : ValueOperations\n",
    "\n",
    "GETDEL -> getAndDelete"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "\"How about a once per customer use-case?\"\n",
      "(nil)\n"
     ]
    }
   ],
   "source": [
    "redis-cli set leapaheadkey 'How about a once per customer use-case?'\n",
    "redis-cli getdel leapaheadkey\n",
    "redis-cli get leapaheadkey"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```java\n",
    "@Component\n",
    "class GetDel implements Function<String, String> {\n",
    "\tprivate final StringRedisTemplate redisTemplate;\n",
    "\tpublic GetDel(StringRedisTemplate redisTemplate){\n",
    "\t\tthis.redisTemplate = redisTemplate;\n",
    "\t}\n",
    "\t@Override\n",
    "\tpublic String apply(String input) {\n",
    "\t\treturn redisTemplate.opsForValue().getAndDelete(input);\n",
    "\t}\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "One-time-use-token AKA OTUT\n",
      "\n",
      "{\"timestamp\":\"2021-09-02T20:15:40.884+00:00\",\"path\":\"/get\",\"status\":500,\"error\":\"Internal Server Error\",\"requestId\":\"42d61014-1\"}"
     ]
    }
   ],
   "source": [
    "curl -H \"Content-Type: application/json\" localhost:8080/set -d '{\"key\":\"leapahead-string\",\"value\":\"One-time-use-token AKA OTUT\"}'\n",
    "echo ''\n",
    "curl -H \"Content-Type: application/json\" localhost:8080/getDel -d 'leapahead-string'\n",
    "echo ''\n",
    "echo ''\n",
    "curl -H \"Content-Type: text/plain\" localhost:8080/get -d 'leapahead-string'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### String : ValueOperations\n",
    "\n",
    "SET PXAT & EXAT\n",
    "\n",
    "Add PXAT/EXAT arguments to SET command (#8327)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "1662163200000 is September 3, 2022\n",
      "There are 31536000 seconds in a year\n",
      "(integer) 31549407\n",
      "\n",
      "OK\n",
      "\n",
      "(integer) 31549407\n"
     ]
    }
   ],
   "source": [
    "redis-cli set leapaheadkey 'This offer will not last' PXAT 1662163200000\n",
    "echo '1662163200000 is September 3, 2022'\n",
    "echo 'There are 31536000 seconds in a year'\n",
    "redis-cli ttl leapaheadkey\n",
    "echo ''\n",
    "redis-cli set leapaheadkey2 'I will glady pay you later for a hamburger today' EXAT 1662163200\n",
    "echo ''\n",
    "redis-cli ttl leapaheadkey2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```java\n",
    "@Component\n",
    "class SetPX implements Function<PX, String> {\n",
    "\tprivate final StringRedisTemplate redisTemplate;\n",
    "\tpublic SetPX(StringRedisTemplate redisTemplate){\n",
    "\t\tthis.redisTemplate = redisTemplate;\n",
    "\t}\n",
    "\t@Override\n",
    "\tpublic String apply(PX input) {\n",
    "\t\tObjects.requireNonNull(redisTemplate.getConnectionFactory())\n",
    "\t\t\t\t.getConnection()\n",
    "\t\t\t\t.set(input.getKey().getBytes(StandardCharsets.UTF_8),\n",
    "\t\t\t\t\t\tinput.getValue().getBytes(StandardCharsets.UTF_8),\n",
    "\t\t\t\t\t\tExpiration.unixTimestamp(Long.parseLong(input.getP()), TimeUnit.MILLISECONDS),\n",
    "\t\t\t\t\t\tRedisStringCommands.SetOption.UPSERT);\n",
    "\t\treturn \"OK\";\n",
    "\t}\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "Self-Destructing\n",
      "{\"timestamp\":\"2021-09-02T20:17:35.845+00:00\",\"path\":\"/get\",\"status\":500,\"error\":\"Internal Server Error\",\"requestId\":\"6435f396-1\"}"
     ]
    }
   ],
   "source": [
    "curl -H \"Content-Type: application/json\" localhost:8080/setPxAt -d '{\"key\":\"leapahead-string\",\"value\":\"Self-Destructing\",\"p\":\"'\"$(($(date +%s000) + 2000))\"'\"}'\n",
    "echo ''\n",
    "curl -H \"Content-Type: text/plain\" localhost:8080/get -d 'leapahead-string'\n",
    "sleep 2\n",
    "echo ''\n",
    "curl -H \"Content-Type: text/plain\" localhost:8080/get -d 'leapahead-string'\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```java\n",
    "@Component\n",
    "public class SetExAt implements Function<Map<String,String>, String> {\n",
    "    private final RedisTemplate redisTemplate;\n",
    "\n",
    "    public SetExAt(RedisTemplate redisTemplate) {\n",
    "        this.redisTemplate = redisTemplate;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public String apply(Map<String,String> input) {\n",
    "        Objects.requireNonNull(redisTemplate.getConnectionFactory())\n",
    "                .getConnection()\n",
    "                .set(input.get(\"key\").getBytes(StandardCharsets.UTF_8),\n",
    "                        input.get(\"value\").getBytes(StandardCharsets.UTF_8),\n",
    "                        Expiration.unixTimestamp(Long.parseLong(input.get(\"e\")), TimeUnit.SECONDS),\n",
    "                        RedisStringCommands.SetOption.UPSERT);\n",
    "        return \"OK\";\n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "Self-Destructing\n",
      "{\"timestamp\":\"2021-09-02T20:18:03.126+00:00\",\"path\":\"/get\",\"status\":500,\"error\":\"Internal Server Error\",\"requestId\":\"ebf9ec44-1\"}"
     ]
    }
   ],
   "source": [
    "curl -H \"Content-Type: application/json\" localhost:8080/setExAt -d '{\"key\":\"leapahead-string\",\"value\":\"Self-Destructing\",\"e\":\"'\"$(($(date +%s) + 2))\"'\"}'\n",
    "echo ''\n",
    "curl -H \"Content-Type: text/plain\" localhost:8080/get -d 'leapahead-string'\n",
    "sleep 2\n",
    "echo ''\n",
    "curl -H \"Content-Type: text/plain\" localhost:8080/get -d 'leapahead-string'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Quiz Time\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What is the maximum size of a Redis Key?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "# 512MB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What is the maximum size of a Redis Value?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "# 512MB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Hash\n",
    "\n",
    "- Maps between string fields and string values\n",
    "- A single hash can store over 4 billion field-value pairs\n",
    "- Closely resembles Java Map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Hash : HashOperations\n",
    "\n",
    "HSET / HMSET / HGETALL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "(integer) 1\n",
      " 1) \"status\"\n",
      " 2) \"So far, so good\"\n",
      " 3) \"track\"\n",
      " 4) \"Beginner, trending in the right direction\"\n",
      " 5) \"conf\"\n",
      " 6) \"SpringOne 2021\"\n",
      " 7) \"presentedBy\"\n",
      " 8) \"@dashaun, @bsbodden\"\n",
      " 9) \"currentTime\"\n",
      "10) \"Thu Sep  2 15:19:51 CDT 2021\"\n"
     ]
    }
   ],
   "source": [
    "redis-cli hmset leapahead:session status \"So far, so good\" track \"Beginner, trending in the right direction\" conf \"SpringOne 2021\" presentedBy \"@dashaun, @bsbodden\"\n",
    "redis-cli hset leapahead:session currentTime \"$(date)\"\n",
    "redis-cli hgetall leapahead:session\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```java\n",
    "@Component\n",
    "public class Hset implements Function<Map<String,String>, String> {\n",
    "        private final StringRedisTemplate redisTemplate;\n",
    "        public Hset(StringRedisTemplate redisTemplate){\n",
    "            this.redisTemplate = redisTemplate;\n",
    "        }\n",
    "        @Override\n",
    "        public String apply(Map<String,String> input) {\n",
    "            redisTemplate.opsForHash().put(input.get(\"k\"),input.get(\"f\"),input.get(\"v\"));\n",
    "            return \"OK\";\n",
    "        }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```java\n",
    "@Component\n",
    "public class Hmset implements Function<Map<?,?>, String> {\n",
    "        private final StringRedisTemplate redisTemplate;\n",
    "        public Hmset(StringRedisTemplate redisTemplate){\n",
    "            this.redisTemplate = redisTemplate;\n",
    "        }\n",
    "        @Override\n",
    "        public String apply(Map<?,?> input) {\n",
    "            redisTemplate.opsForHash().putAll((String)input.get(\"key\")\n",
    "                    ,(Map<?,?>)input.get(\"f\"));\n",
    "            return \"OK\";\n",
    "        }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```java\n",
    "@Component\n",
    "public class HgetAll implements Function<String, Map<?,?>> {\n",
    "        private final RedisTemplate redisTemplate;\n",
    "        public HgetAll(RedisTemplate redisTemplate){\n",
    "            this.redisTemplate = redisTemplate;\n",
    "        }\n",
    "        @Override\n",
    "        public Map<?,?> apply(String input) {\n",
    "            return redisTemplate.opsForHash().entries(input);\n",
    "        }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "OK\n",
      "{}\n",
      "1) \"start\"\n",
      "2) \"dotspringdotio\"\n",
      "3) \"Leap\"\n",
      "4) \"Ahead\"\n",
      "5) \"Redis\"\n",
      "6) \"6.2\"\n"
     ]
    }
   ],
   "source": [
    "curl -H \"Content-Type: application/json\" localhost:8080/hset -d '{\"k\":\"SpringOne2021\",\"f\":\"start\",\"v\":\"dotspringdotio\"}'\n",
    "echo ''\n",
    "curl -H \"Content-Type: application/json\" localhost:8080/hmset -d '{\"key\":\"SpringOne2021\",\"f\":{\"Leap\":\"Ahead\",\"Redis\":\"6.2\"}}'\n",
    "echo ''\n",
    "curl -H \"Content-Type: text/plain\" localhost:8080/hgetAll -d 'SpringOne2021'\n",
    "echo ''\n",
    "redis-cli hgetall SpringOne2021"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Hash : HashOperations\n",
    "\n",
    "HRANDFIELD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "\n",
      "1) \"5\"\n",
      "2) \"Sandy\"\n",
      "3) \"4\"\n",
      "4) \"Whit\"\n",
      "5) \"2\"\n",
      "6) \"Pat\"\n",
      "7) \"1\"\n",
      "8) \"Johnny\"\n"
     ]
    }
   ],
   "source": [
    "redis-cli hmset team:frontend 1 \"Johnny\" 2 \"Pat\" 3 \"Nat\" 4 \"Whit\" 5 \"Sandy\"\n",
    "echo ''\n",
    "redis-cli hrandfield team:frontend 4 WITHVALUES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```java\n",
    "@Component\n",
    "public class HrandField implements Function<Map<String,String>, List<String>> {\n",
    "        private final StringRedisTemplate redisTemplate;\n",
    "        public HrandField(StringRedisTemplate redisTemplate){\n",
    "            this.redisTemplate = redisTemplate;\n",
    "        }\n",
    "        @Override\n",
    "        public List<String> apply(Map<String,String> input) {\n",
    "            return ((StringRedisConnection)redisTemplate.getConnectionFactory().getConnection())\n",
    "                    .hRandField(input.get(\"key\"),\n",
    "                            Long.parseLong(input.get(\"count\")));\n",
    "        }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```java\n",
    "@Component\n",
    "public class HrandFieldWithValues implements Function<Map<String,String>, List<Map.Entry<String, String>>> {\n",
    "        private final StringRedisConnection stringRedisConnection;\n",
    "        public HrandFieldWithValues(StringRedisConnection stringRedisConnection){\n",
    "            this.stringRedisConnection = stringRedisConnection;\n",
    "        }\n",
    "        @Override\n",
    "        public List<Map.Entry<String, String>> apply(Map<String,String> input) {\n",
    "            return stringRedisConnection.hRandFieldWithValues(input.get(\"key\"),\n",
    "                            Long.parseLong(input.get(\"count\")));\n",
    "        }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "[\"RedisBloom\",\"Azure\"]\n",
      "[\"RedisBloom\",\"Harvester\",\"RedisBloom\",\"OpenShift\",\"OpenShift\"]\n",
      "[{\"Harvester\":\"Suse\"},{\"OpenShift\":\"Redis Enterprise Operator\"}]"
     ]
    }
   ],
   "source": [
    "curl -H \"Content-Type: application/json\" localhost:8080/hmset -d '{\"key\":\"Leaping\",\"f\":{\"Raspberry Pi 4\":\"k3os\",\"Harvester\":\"Suse\",\"RedisBloom\":\"Azure Cache for Redis Enterprise\",\"Azure\":\"RedisTimeSeries\",\"Redis OSS\":\"6.2\",\"OpenShift\":\"Redis Enterprise Operator\"}}'\n",
    "echo ''\n",
    "curl -H \"Content-Type: application/json\" localhost:8080/hrandField -d '{\"key\":\"Leaping\",\"count\":\"2\"}'\n",
    "echo ''\n",
    "curl -H \"Content-Type: application/json\" localhost:8080/hrandField -d '{\"key\":\"Leaping\",\"count\":\"-5\"}'\n",
    "echo ''\n",
    "curl -H \"Content-Type: application/json\" localhost:8080/hrandFieldWithValues -d '{\"key\":\"Leaping\",\"count\":\"2\"}'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Cheat Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Don't try to remember the Redis commands."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Remember Spring Data Redis!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### List\n",
    "\n",
    "- An ordered sequence of strings\n",
    "- Comparable to a Java ArrayList\n",
    "- Multi-purpose:\n",
    "  - Stacks\n",
    "  - Queues\n",
    "- A single List can hold over 4 billion entries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Adding to a List\n",
    "\n",
    "- You can **add** things by:\n",
    "  - **Pushing** in: `LPUSH`/`LPUSHX`, `RPUSH`/`RPUSHX`\n",
    "  - **Inserting** before/after: `LINSERT`\n",
    "  - **Setting** the value at an **index**: `LSET`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Remove from a List\n",
    "\n",
    "- You can **remove things** things by:\n",
    "  - **Popping** off: `LPOP`/`RPOP`/`BLPOP`/`BRPOP`\n",
    "  - **By value** `LREM`\n",
    "  - **By index** range: `LTRIM`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Accessing Elements\n",
    "\n",
    "- **By index**: `LINDEX`\n",
    "- **By range**: `LRANGE`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Between Lists\n",
    "\n",
    "- **Last** from one list, **to first** in another: `RPOPLPUSH`/`BRPOPLPUSH`\n",
    "- **Pop** and then **Push**: `LMOVE`/`BLMOVE`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(integer) 0\n",
      "(integer) 3\n",
      "\n",
      "1) \"Shenanigans\"\n",
      "2) \"Bamboozle\"\n",
      "3) \"Bodacious\"\n"
     ]
    }
   ],
   "source": [
    "redis-cli DEL funny_words\n",
    "redis-cli RPUSH funny_words \"Shenanigans\" \"Bamboozle\" \"Bodacious\"\n",
    "echo ''\n",
    "redis-cli LRANGE funny_words 0 -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1) \"Shenanigans\"\n",
      "2) \"Bamboozle\"\n",
      "3) \"Bodacious\"\n",
      "\n",
      "(integer) 4\n",
      "\n",
      "1) \"Bumfuzzle\"\n",
      "2) \"Shenanigans\"\n",
      "3) \"Bamboozle\"\n",
      "4) \"Bodacious\"\n"
     ]
    }
   ],
   "source": [
    "redis-cli LRANGE funny_words 0 -1\n",
    "echo ''\n",
    "redis-cli LPUSH funny_words \"Bumfuzzle\"\n",
    "echo ''\n",
    "redis-cli LRANGE funny_words 0 -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1) \"Shenanigans\"\n",
      "2) \"Bamboozle\"\n",
      "3) \"Bodacious\"\n",
      "\n",
      "(integer) 5\n",
      "\n",
      "OK\n",
      "\n",
      "1) \"Bumfuzzle\"\n",
      "2) \"Shenanigans\"\n",
      "3) \"Brouhaha\"\n",
      "4) \"Flibbertigibbet\"\n",
      "5) \"Bodacious\"\n"
     ]
    }
   ],
   "source": [
    "redis-cli LRANGE funny_words 1 3\n",
    "echo ''\n",
    "redis-cli LINSERT funny_words BEFORE \"Bamboozle\" \"Brouhaha\"\n",
    "echo ''\n",
    "redis-cli LSET funny_words -2 \"Flibbertigibbet\"\n",
    "echo ''\n",
    "redis-cli LRANGE funny_words 0 -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1) \"Bumfuzzle\"\n",
      "2) \"Shenanigans\"\n",
      "3) \"Brouhaha\"\n",
      "4) \"Flibbertigibbet\"\n",
      "5) \"Bodacious\"\n",
      "\n",
      "\"Bumfuzzle\"\n",
      "\n",
      "1) \"Shenanigans\"\n",
      "2) \"Brouhaha\"\n",
      "3) \"Flibbertigibbet\"\n",
      "4) \"Bodacious\"\n"
     ]
    }
   ],
   "source": [
    "redis-cli LRANGE funny_words 0 -1\n",
    "echo ''\n",
    "redis-cli LPOP funny_words\n",
    "echo ''\n",
    "redis-cli LRANGE funny_words 0 -1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### In Spring Data Redis\n",
    "\n",
    "```java\n",
    "public class ListExample {\n",
    "\n",
    "  @Autowired\n",
    "  private StringRedisTemplate redisTemplate;\n",
    "\n",
    "  @Resource(name=\"stringRedisTemplate\")\n",
    "  private ListOperations<String, String> listOps;\n",
    "\n",
    "  public void playWithLists() {\n",
    "    //...\n",
    "  }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### In Spring Data Redis\n",
    "\n",
    "```java\n",
    "public void playWithLists() {\n",
    "  listOps.rightPushAll(\"funny_words\", \"Shenanigans\", \"Bamboozle\", \"Bodacious\");\n",
    "  List<String> range = listOps.range(\"funny_words\", 0, -1);\n",
    "  System.out.println(range.toArray());\n",
    "\n",
    "  listOps.leftPush(\"funny_words\", \"Bumfuzzle\");\n",
    "  range = listOps.range(\"funny_words\", 1, 3);\n",
    "\n",
    "  listOps.leftPush(\"funny_words\", \"Bamboozle\", \"Brouhaha\");\n",
    "  // ...\n",
    "\n",
    "  listOps.set(\"funny_words\", -2, \"Flibbertigibbet\");\n",
    "  // ...\n",
    "  System.out.println(listOps.size(\"funny_words\"));\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### What's new with Lists in 6.2?\n",
    "\n",
    "- Add `LMOVE` and `BLMOVE` commands that pop and push arbitrarily (#6929)\n",
    "- Add the `COUNT `argument to `LPOP` and `RPOP` (#8179)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `LMOVE` on the CLI\n",
    "\n",
    "- Right-most from `list_one` to the left of `list_two`\n",
    "- Left-most from `list_one` to the left of `list_two`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(integer) 0\n",
      "(integer) 0\n",
      "(integer) 3\n",
      "\n",
      "\"three\"\n",
      "\n",
      "\"one\"\n",
      "\n",
      "1) \"two\"\n",
      "\n",
      "1) \"three\"\n",
      "2) \"one\"\n"
     ]
    }
   ],
   "source": [
    "redis-cli DEL list_one\n",
    "redis-cli DEL list_two\n",
    "redis-cli RPUSH list_one \"one\" \"two\" \"three\"\n",
    "echo ''\n",
    "redis-cli LMOVE list_one list_two RIGHT LEFT\n",
    "echo ''\n",
    "redis-cli LMOVE list_one list_two LEFT RIGHT\n",
    "echo ''\n",
    "redis-cli LRANGE list_one 0 -1\n",
    "echo ''\n",
    "redis-cli LRANGE list_two 0 -1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `LMOVE` on SDR as a JUnit Test\n",
    "\n",
    "```java\n",
    "@Test\n",
    "void testLMOVE() {\n",
    "  listOps.rightPushAll(\"list_one\", \"one\", \"two\", \"three\");\n",
    "  listOps.move(\"list_one\", RIGHT, \"list_two\", LEFT);\n",
    "  listOps.move(\"list_one\", LEFT, \"list_two\", RIGHT);\n",
    "\n",
    "  List<String> listOne = listOps.range(\"list_one\", 0, -1);\n",
    "  List<String> listTwo = listOps.range(\"list_two\", 0, -1);\n",
    "\n",
    "  assertTrue(listOne.containsAll(List.of(\"two\")));\n",
    "  assertTrue(listTwo.containsAll(List.of(\"three\", \"one\")));\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "###  `COUNT` on `LPOP`/`RPOP`\n",
    "\n",
    "Pop \"n\" things from the left or the right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(integer) 1\n",
      "(integer) 2\n",
      "(integer) 3\n",
      "1) \"one\"\n",
      "2) \"two\"\n",
      "1) \"three\"\n"
     ]
    }
   ],
   "source": [
    "redis-cli RPUSH mylist \"one\"\n",
    "redis-cli RPUSH mylist \"two\"\n",
    "redis-cli RPUSH mylist \"three\"\n",
    "redis-cli LPOP mylist 2\n",
    "redis-cli LRANGE mylist 0 -1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `COUNT` on `LPOP`/`RPOP` on SDR as a JUnit Test\n",
    "\n",
    "```java\n",
    "@Test\n",
    "void testLPOP() {\n",
    "  listOps.rightPush(\"mylist\", \"one\");\n",
    "  listOps.rightPush(\"mylist\", \"two\");\n",
    "  listOps.rightPush(\"mylist\", \"three\");\n",
    "  listOps.leftPop(\"mylist\", 2);\n",
    "  List<String> myList = listOps.range(\"mylist\", 0, -1);\n",
    "  assertTrue(myList.containsAll(List.of(\"three\")));\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Set\n",
    "\n",
    "- Collections of unique, unsorted string elements.\n",
    "- Set Operations (Union/Intersection/Subtraction)\n",
    "- Most operations in constant time (`O(n)`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Set Use Cases\n",
    "\n",
    "- Unique item management (tags/folksonomies)\n",
    "- Tracking IPs, content filtering\n",
    "- As a support data structure to manage membership\n",
    "  - SDR maintains Primary Keys for mapped classes in a Redis Set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Working with Sets\n",
    "\n",
    "- Add/Remove: `SADD` / `SPOP` / `SREM`\n",
    "- Access/Retrieve: `SMEMBERS` / `SRANDMEMBERS` / `SSCAN`\n",
    "- Set Info: `SCARD` / `SISMEMBER` / `SMISMEMBER`\n",
    "- Set Ops: `SDIFF*`/  `SINTER*` / `SUNION*` / `SMOVE`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(integer) 0\n",
      "(integer) 4\n",
      "(integer) 0\n",
      "(integer) 1\n",
      "(integer) 0\n",
      "(integer) 1\n",
      "(integer) 0\n",
      "1) \"yellow\"\n",
      "2) \"fushia\"\n",
      "3) \"red\"\n"
     ]
    }
   ],
   "source": [
    "redis-cli DEL colors\n",
    "redis-cli SADD colors \"red\" \"yellow\" \"green\" \"fushia\"\n",
    "redis-cli SADD colors \"yellow\"\n",
    "redis-cli SISMEMBER colors \"green\"\n",
    "redis-cli SISMEMBER colors \"magenta\"\n",
    "redis-cli SREM colors \"green\"\n",
    "redis-cli SREM colors \"green\"\n",
    "redis-cli SMEMBERS colors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Sets in Spring Data Redis\n",
    "\n",
    "```java\n",
    "@Test\n",
    "void testSimpleExample() {\n",
    "  setOps.add(\"colors\", \"red\", \"yellow\", \"green\", \"fushia\");\n",
    "  setOps.add(\"colors\", \"yellow\");\n",
    "  Set<String> members = setOps.members(\"colors\");\n",
    "  assertTrue(members.containsAll(List.of(\"red\", \"yellow\", \"green\", \"fushia\")));\n",
    "  assertTrue(setOps.isMember(\"colors\", \"green\"));\n",
    "  assertFalse(setOps.isMember(\"colors\", \"magenta\"));\n",
    "  assertEquals(1, setOps.remove(\"colors\", \"green\"));\n",
    "  members = setOps.members(\"colors\");\n",
    "  assertTrue(members.containsAll(List.of(\"red\", \"yellow\", \"fushia\")));\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### What's new with Sets in 6.2?\n",
    "\n",
    "- Add `SMISMEMBER` command that checks multiple members (#7615)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(integer) 1\n",
      "(integer) 4\n",
      "1) (integer) 1\n",
      "2) (integer) 0\n",
      "3) (integer) 1\n"
     ]
    }
   ],
   "source": [
    "redis-cli DEL colors\n",
    "redis-cli SADD colors \"red\" \"yellow\" \"green\" \"fushia\"\n",
    "redis-cli SMISMEMBER colors \"red\" \"black\" \"green\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `SMISMEMBER` on SDR as a JUnit Test\n",
    "\n",
    "```java\n",
    "@Test\n",
    "void testSMISMEMBER() {\n",
    "  setOps.add(\"colors\", \"red\", \"yellow\", \"green\", \"fushia\");\n",
    "  Map<Object, Boolean> memberCheck = setOps.isMember(\"colors\", \"red\", \"black\", \"green\");\n",
    "  assertTrue(memberCheck.get(\"red\"));\n",
    "  assertFalse(memberCheck.get(\"black\"));\n",
    "  assertTrue(memberCheck.get(\"green\"));\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK\n",
      "(integer) 4\n",
      "1) (integer) 1\n",
      "2) (integer) 0\n",
      "3) (integer) 1\n"
     ]
    }
   ],
   "source": [
    "redis-cli flushdb\n",
    "redis-cli SADD colors \"red\" \"yellow\" \"green\" \"fushia\"\n",
    "redis-cli SMISMEMBER colors \"red\" \"black\" \"green\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Sorted Set\n",
    "\n",
    "- A weighted Sets: A mix between a `Set` and a `Hash`\n",
    "- Elements\n",
    "  - are tuples with a **value** and a **score**\n",
    "  - are always taken sorted by their score\n",
    "  - can be retrieved in ranges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Sorted Set Use Cases\n",
    "\n",
    "- Priority queues\n",
    "- Low-latency leaderboards\n",
    "- Secondary indexing in general"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(integer) 5\n",
      "(integer) 6\n",
      "\n",
      " 1) \"Frank\"\n",
      " 2) \"200\"\n",
      " 3) \"Joe\"\n",
      " 4) \"212\"\n",
      " 5) \"Jennifer\"\n",
      " 6) \"230\"\n",
      " 7) \"Mary\"\n",
      " 8) \"450\"\n",
      " 9) \"Dave\"\n",
      "10) \"512\"\n",
      "11) \"Tom\"\n",
      "12) \"730\"\n"
     ]
    }
   ],
   "source": [
    "redis-cli ZADD game1 100 \"Frank\" 740 \"Jennifer\" 200 \"Pieter\" 512 \"Dave\" 690 \"Ana\"\n",
    "redis-cli ZADD game2 212 \"Joe\" 230 \"Jennifer\" 450 \"Mary\" 730 \"Tom\" 512 \"Dave\" 200 \"Frank\"\n",
    "echo ''\n",
    "redis-cli ZRANGE game2 0 -1 WITHSCORES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1) \"Frank\"\n",
      "2) \"300\"\n",
      "3) \"Jennifer\"\n",
      "4) \"970\"\n",
      "5) \"Dave\"\n",
      "6) \"1024\"\n",
      "\n",
      "1) \"Frank\"\n",
      "2) \"200\"\n",
      "3) \"Dave\"\n",
      "4) \"512\"\n",
      "5) \"Jennifer\"\n",
      "6) \"740\"\n",
      "\n",
      "1) \"Pieter\"\n",
      "2) \"200\"\n",
      "3) \"Ana\"\n",
      "4) \"690\"\n"
     ]
    }
   ],
   "source": [
    "redis-cli ZINTER 2 game1 game2 WITHSCORES\n",
    "echo ''\n",
    "redis-cli ZINTER 2 game1 game2 WITHSCORES AGGREGATE max\n",
    "echo ''\n",
    "redis-cli ZDIFF 2 game1 game2 WITHSCORES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `ZADD` in SDR\n",
    "\n",
    "```java\n",
    "Set<TypedTuple<String>> game1 = Set.of( //\n",
    "    TypedTuple.of(\"Frank\", 100.0), TypedTuple.of(\"Jennifer\", 740.0),\n",
    "    TypedTuple.of(\"Pieter\", 200.0), TypedTuple.of(\"Dave\", 512.0),\n",
    "    TypedTuple.of(\"Ana\", 690.0));\n",
    "\n",
    "Set<TypedTuple<String>> game2 = Set.of( //\n",
    "    TypedTuple.of(\"Joe\", 212.0), TypedTuple.of(\"Jennifer\", 230.0),\n",
    "    TypedTuple.of(\"Mary\", 450.0), TypedTuple.of(\"Tom\", 730.0),\n",
    "    TypedTuple.of(\"Dave\", 512.0), TypedTuple.of(\"Frank\", 200.0));\n",
    "\n",
    "zSetOps.add(\"game1\", game1);\n",
    "zSetOps.add(\"game2\", game2);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `ZRANGE` in SDR\n",
    "\n",
    "```java\n",
    "Set<String> game1Players = zSetOps.range(\"game1\", 0, -1);\n",
    "assertArrayEquals(new String[] { \"Frank\", \"Pieter\", \"Dave\", \"Ana\", \"Jennifer\"}, game1Players.toArray());\n",
    "\n",
    "Set<TypedTuple<String>> game2PlayersWithScores = zSetOps.rangeWithScores(\"game2\", 0, -1);\n",
    "TypedTuple<String> frankInGame2 = game2PlayersWithScores.iterator().next();\n",
    "assertEquals(\"Frank\", frankInGame2.getValue());\n",
    "assertEquals(200.0, frankInGame2.getScore());\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `ZINTER` in SDR\n",
    "\n",
    "```java\n",
    "Set<TypedTuple<String>> inBothGames = zSetOps.intersectWithScores(\"game1\", \"game2\");\n",
    "TypedTuple<String> frankInBothGamesTotal = inBothGames.iterator().next();\n",
    "assertEquals(\"Frank\", frankInBothGamesTotal.getValue());\n",
    "assertEquals(300.0, frankInBothGamesTotal.getScore());\n",
    "\n",
    "Set<TypedTuple<String>> inBothGamesWithMax = zSetOps.intersectWithScores(\"game1\", Set.of(\"game2\"), Aggregate.MAX);\n",
    "TypedTuple<String> frankInBothGamesMax = inBothGamesWithMax.iterator().next();\n",
    "assertEquals(\"Frank\", frankInBothGamesMax.getValue());\n",
    "assertEquals(200.0, frankInBothGamesMax.getScore());\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `ZDIFF` in SDR\n",
    "\n",
    "```java\n",
    "Set<TypedTuple<String>> onlyInGame1 = zSetOps.differenceWithScores(\"game1\", \"game2\");\n",
    "List<String> players = onlyInGame1.stream().map(t -> t.getValue()).collect(Collectors.toList());\n",
    "assertTrue(players.containsAll(Set.of(\"Pieter\", \"Ana\")));\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Sorted Set\n",
    "\n",
    "- Add ZMSCORE command that returns an array of scores (#7593)\n",
    "- Add ZDIFF and ZDIFFSTORE commands (#7961)\n",
    "- Add ZINTER and ZUNION commands (#7794)\n",
    "- Add ZRANDMEMBER command (#8297)\n",
    "- Add the REV, BYLEX and BYSCORE arguments to ZRANGE, and the ZRANGESTORE command (#7844)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ZMSCORE w/ an array of scores\n",
      "\n",
      "(integer) 1\n",
      "(integer) 1\n",
      "1) \"1\"\n",
      "2) \"2\"\n",
      "3) (nil)\n"
     ]
    }
   ],
   "source": [
    "echo 'ZMSCORE w/ an array of scores'\n",
    "echo ''\n",
    "redis-cli ZADD myzset 1 \"one\"\n",
    "redis-cli ZADD myzset 2 \"two\"\n",
    "redis-cli ZMSCORE myzset \"one\" \"two\" \"nofield\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### ZMSCORE w/ an array of scores\n",
    "\n",
    "```java\n",
    "@Test\n",
    "void testZMSCORE() {\n",
    "  zSetOps.add(\"myzset\", \"one\", 1);\n",
    "  zSetOps.add(\"myzset\", \"two\", 2);\n",
    "  List<Double> scores = zSetOps.score(\"myzset\", \"one\", \"two\", \"nofield\");\n",
    "\n",
    "  assertArrayEquals(new Double[] { 1.0, 2.0, null }, scores.toArray());\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ZDIFF Commands\n",
      "\n",
      "(integer) 1\n",
      "(integer) 1\n",
      "(integer) 1\n",
      "(integer) 1\n",
      "(integer) 1\n",
      "1) \"three\"\n",
      "\n",
      "1) \"three\"\n",
      "2) \"3\"\n"
     ]
    }
   ],
   "source": [
    "echo 'ZDIFF Commands'\n",
    "echo ''\n",
    "redis-cli ZADD zset1 1 \"one\"\n",
    "redis-cli ZADD zset1 2 \"two\"\n",
    "redis-cli ZADD zset1 3 \"three\"\n",
    "redis-cli ZADD zset2 1 \"one\"\n",
    "redis-cli ZADD zset2 2 \"two\"\n",
    "redis-cli ZDIFF 2 zset1 zset2\n",
    "echo ''\n",
    "redis-cli ZDIFF 2 zset1 zset2 WITHSCORES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### ZDIFF commands\n",
    "\n",
    "```java\n",
    "@Test\n",
    "void testZDIFF() {\n",
    "  zSetOps.add(\"zset1\", \"one\", 1);\n",
    "  zSetOps.add(\"zset1\", \"two\", 2);\n",
    "  zSetOps.add(\"zset1\", \"three\", 3);\n",
    "  zSetOps.add(\"zset2\", \"one\", 1);\n",
    "  zSetOps.add(\"zset2\", \"two\", 2);\n",
    "\n",
    "  Set<String> diffs = zSetOps.difference(\"zset1\", \"zset2\");\n",
    "  assertArrayEquals(new String[] { \"three\" }, diffs.toArray());\n",
    "\n",
    "  Set<TypedTuple<String>> diffsWScores = zSetOps.differenceWithScores(\"zset1\", \"zset2\");\n",
    "  assertEquals(1, diffsWScores.size());\n",
    "  TypedTuple<String> dtt = diffsWScores.iterator().next();\n",
    "  assertEquals(\"three\", dtt.getValue());\n",
    "  assertEquals(3.0, dtt.getScore());\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ZDIFFSTORE commands\n",
      "\n",
      "(integer) 0\n",
      "(integer) 0\n",
      "(integer) 0\n",
      "(integer) 0\n",
      "(integer) 0\n",
      "\n",
      "(integer) 1\n",
      "\n",
      "1) \"three\"\n",
      "2) \"3\"\n"
     ]
    }
   ],
   "source": [
    "echo 'ZDIFFSTORE commands'\n",
    "echo ''\n",
    "redis-cli ZADD zset1 1 \"one\"\n",
    "redis-cli ZADD zset1 2 \"two\"\n",
    "redis-cli ZADD zset1 3 \"three\"\n",
    "redis-cli ZADD zset2 1 \"one\"\n",
    "redis-cli ZADD zset2 2 \"two\"\n",
    "echo ''\n",
    "redis-cli ZDIFFSTORE out 2 zset1 zset2\n",
    "echo ''\n",
    "redis-cli ZRANGE out 0 -1 WITHSCORES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### ZDIFFSTORE commands\n",
    "\n",
    "```java\n",
    "@Test\n",
    "void testZDIFFSTORE() {\n",
    "  zSetOps.add(\"zset1\", \"one\", 1);\n",
    "  zSetOps.add(\"zset1\", \"two\", 2);\n",
    "  zSetOps.add(\"zset1\", \"three\", 3);\n",
    "  zSetOps.add(\"zset2\", \"one\", 1);\n",
    "  zSetOps.add(\"zset2\", \"two\", 2);\n",
    "\n",
    "  zSetOps.differenceAndStore(\"zset1\", List.of(\"zset2\"), \"out\");\n",
    "  Set<TypedTuple<String>> withScores = zSetOps.rangeWithScores(\"out\", 0, -1);\n",
    "  assertEquals(1, withScores.size());\n",
    "  TypedTuple<String> dtt = withScores.iterator().next();\n",
    "  assertEquals(\"three\", dtt.getValue());\n",
    "  assertEquals(3.0, dtt.getScore());\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Geo\n",
    "\n",
    "- Sorted Set\n",
    "- Latitude and longitude encoded into the score of the sorted set using the geohash algorithm\n",
    "- \"lat long\" isn't the case here, it's \"long lat\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(integer) 1\n",
      "(integer) 1\n",
      "(integer) 1\n",
      "(integer) 1\n",
      "(integer) 1\n",
      "(integer) 1\n",
      "\"3527.3727\"\n",
      "(integer) 1\n"
     ]
    }
   ],
   "source": [
    "redis-cli GEOADD running-poi -94.188224 39.013319 \"Football\"\n",
    "redis-cli GEOADD running-poi -94.194606 39.018836 \"Track\"\n",
    "redis-cli GEOADD running-poi -94.207570 39.019566 \"Trail\"\n",
    "redis-cli GEOADD running-poi -94.238336 39.029377 \"Lake\"\n",
    "redis-cli GEOADD running-poi -94.231930 39.066619 \"Park\"\n",
    "redis-cli GEOADD running-poi -94.213729 39.038229 \"Basketball\"\n",
    "redis-cli GEODIST running-poi \"Park\" \"Basketball\"\n",
    "redis-cli DEL running-poi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```java\n",
    "@Component\n",
    "public class GeoAdd implements Function<Map<String,String>, Long> {\n",
    "        private final StringRedisTemplate redisTemplate;\n",
    "        public GeoAdd(StringRedisTemplate redisTemplate){\n",
    "            this.redisTemplate = redisTemplate;\n",
    "        }\n",
    "        @Override\n",
    "        public Long apply(Map<String,String> input) {\n",
    "            Point p = new Point(Double.parseDouble(input.get(\"long\")),\n",
    "                    Double.parseDouble(input.get(\"lat\")));\n",
    "            return redisTemplate.opsForGeo().add(input.get(\"k\"),p,input.get(\"m\"));\n",
    "        }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "curl -H \"Content-Type: application/json\" localhost:8080/geoAdd -d '{\"k\":\"running-poi\",\"lat\":\"39.038229\",\"long\":\"-94.213729\",\"m\":\"Basketball\"}'\n",
    "echo ''\n",
    "curl -H \"Content-Type: application/json\" localhost:8080/geoAdd -d '{\"k\":\"running-poi\",\"lat\":\"39.019566\",\"long\":\"-94.207570\",\"m\":\"Trail\"}'\n",
    "echo ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1) \"Trail\"\n",
      "2) \"1405606775774309\"\n",
      "3) \"Basketball\"\n",
      "4) \"1405609652767867\"\n"
     ]
    }
   ],
   "source": [
    "curl -H \"Content-Type: application/json\" localhost:8080/geoSearchFromMemberByBoxKm -d '{\"k\":\"running-poi\",\"destK\":\"inTheBox\",\"m\":\"Trail\",\"width\":\"10\",\"height\":\"10\"}'\n",
    "echo ''\n",
    "redis-cli ZRANGE inTheBox 0 -1 WITHSCORES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# WERE YOU PAYING ATTENTION?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## I TOTALLY CHEATED"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## I USED ZRANGE TO GET THE MEMBERS OF THE GEO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1) \"Trail\"\n",
      "2) \"1405606775774309\"\n",
      "3) \"Basketball\"\n",
      "4) \"1405609652767867\"\n"
     ]
    }
   ],
   "source": [
    "redis-cli ZRANGE inTheBox 0 -1 WITHSCORES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# STREAMS\n",
    "\n",
    "- Before Redis 6.2, streams could only be trimmed to an exact or approximate number of entries.\n",
    "- This is a little at odds with the way that we do steam processing\n",
    "- Each entry in a stream must have a unique ID greater than any previously seen in the stream.\n",
    "- Redis by default uses millisecond timestamps for this.\n",
    "- We now allow you to trim based on ID!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Brian!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### What we're up to at Redis\n",
    "\n",
    "- Extending/complementing Spring Data Redis with:\n",
    "  - Access to module commands via Spring's Templates\n",
    "  - Multi-model Object-Mapping support\n",
    "  - JSON object-mapping + RediSearch integration\n",
    "  - Graph object-mapping\n",
    "  - RediSearch integration for existing Redis Hash mapped entities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### What we're up to at Redis\n",
    "\n",
    "- Plus...\n",
    "  - Encapsulated \"Use Cases\" that can be applies declaratively\n",
    "  - Graph object-mapping\n",
    "  - RediSearch integration for existing Redis Hash mapped entities\n",
    "  - Encapsulated \"Use Cases\" that can be applies declaratively"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Redis Modules Templates\n",
    "\n",
    "- Follow's Spring Data Redis \"`opsForXXX()`\" pattern\n",
    "- Provide's a Spring Native way to interact at the command-level with:\n",
    "- RedisJSON, RedisGraph, RediSearch, RedisAI, RedisBloom, and RedisTimeSeries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Redis Modules Templates\n",
    "\n",
    "Inject a `RedisModulesOperations` bean:\n",
    "\n",
    "```java\n",
    "@Autowired\n",
    "RedisModulesOperations<String, String> modulesOperations;\n",
    "```\n",
    "\n",
    "Retrieve a module template to use its commands:\n",
    "\n",
    "```java\n",
    "GraphOperations<String> graph = modulesOperations.opsForGraph();\n",
    "// Create both source and destination nodes\n",
    "graph(\"social\", \"CREATE (:person{name:'roi',age:32})\");\n",
    "graph(\"social\", \"CREATE (:person{name:'amit',age:30})\");\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### RedisJSON Document-Object Mapping\n",
    "\n",
    "Annotate a Java class with `@Document` annotation:\n",
    "\n",
    "```java\n",
    "@Document(\"company\")\n",
    "public class Company {\n",
    "  @Id\n",
    "  private String id;\n",
    "  @NonNull\n",
    "  private String name;\n",
    "  private boolean publiclyListed;\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### RedisJSON Document-Object Mapping\n",
    "\n",
    "Repository support via `RedisDocumentRepository` interface:\n",
    "\n",
    "```java\n",
    "interface CompanyRepository extends RedisDocumentRepository<Company, String> {}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### RedisJSON Document-Object Mapping\n",
    "\n",
    "In action:\n",
    "\n",
    "```java\n",
    "@Autowired CompanyRepository repository;\n",
    "\n",
    "Company redislabs = repository.save(Company.of(\"RedisLabs\"));\n",
    "Company microsoft = repository.save(Company.of(\"Microsoft\"));\n",
    "\n",
    "System.out.println(\">>>> Items in repo: \" + repository.count());\n",
    "\n",
    "Optional<Company> maybeRedisLabs = repository.findById(redislabs.getId());\n",
    "Optional<Company> maybeMicrosoft = repository.findById(microsoft.getId());\n",
    "\n",
    "System.out.println(\">>>> Company: \" + maybeRedisLabs.get());\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### RedisJSON/RediSearch Integration\n",
    "\n",
    "- `@XXXIndexed` Annotations for RediSearch index creation and maintenance\n",
    "\n",
    "```java\n",
    "@Document(\"my-doc\")\n",
    "public class MyDoc {\n",
    "  @Id\n",
    "  private String id;\n",
    "  @NonNull\n",
    "  @TextIndexed(alias = \"title\")\n",
    "  private String title;\n",
    "  @TagIndexed(alias = \"tag\")\n",
    "  private Set<String> tag = new HashSet<String>();\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Search anything...\n",
    "\n",
    "- `@Query` and `@Aggregation` for powerful native RediSearch Queries and Aggregations:\n",
    "\n",
    "```java\n",
    "public interface MyDocRepository\n",
    "  extends RedisDocumentRepository<MyDoc, String>, MyDocQueries {\n",
    "\n",
    "  @Query(returnFields = {\"$.tag[0]\", \"AS\", \"first_tag\"})\n",
    "  SearchResult getFirstTag();\n",
    "\n",
    "  @Query(\"@title:$title @tag:{$tags}\")\n",
    "  Iterable<MyDoc> findByTitleAndTags(@Param(\"title\") String title, @Param(\"tags\") Set<String> tags);\n",
    "\n",
    "  @Aggregation(load = {\"$.tag[1]\", \"AS\", \"tag2\"})\n",
    "  AggregationResult getSecondTagWithAggregation();\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# DEMO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Looking Forward\n",
    "\n",
    "- Today: 2.6 Milestone 2\n",
    "- November 2021: Spring Data Redis 2.6 GA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- One of the best part of this community is contributing\n",
    "- Take the milestone for a spin\n",
    "- Let us know how it works for you"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# THANKS\n",
    "\n",
    "- @bsbodden\n",
    "- @dashaun\n",
    "\n",
    "## https://github.com/LeapAheadWithRedis6-2"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Bash",
   "language": "bash",
   "name": "bash"
  },
  "language_info": {
   "codemirror_mode": "shell",
   "file_extension": ".sh",
   "mimetype": "text/x-sh",
   "name": "bash"
  },
  "rise": {
   "height": "100%",
   "overlay": "<div class='frame'><span class='helper'></span><img src='images/redis-icon.svg' height=200/></div>",
   "scroll": true,
   "slideNumber": false,
   "width": "100%"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}