The Redis Data Types Used in the Database (Part 1)
You may have heard Redis described as a simple key-value store, but it’s actually much more. Traditionally, key-value stores are able to relate string keys with string values; however, Redis is a data structures server, which means that it can store a variety of complex data structures as values. In this article, we’ll discuss some of the common Redis data types and look at examples of their use.
Before proceeding with the examples in this article, make sure that you already have a Redis server running on your machine. You can install Redis on macOS with Homebrew by using the
brew install redis command in a terminal window. You can also install it with
sudo apt-get install redis-server on a Debian-based Linux distribution with the APT-GET repository.
To verify that both
redis-cli are installed, use the command
redis-server --version. It should return something like the following:
Redis server v=5.0.7 sha=00000000:0 malloc=libc bits=64 build=295beb9462eefd91
Redis data types use cases
Redis is known for its ability to perform in-memory data processing, which results in greater speed and efficiency. It is also able to use and process abstract data types (ADT) such as lists and hashes. Abstract data types are more efficient and high-level– code written using them tends to be more comprehensible to human eyes and more compatible with object-oriented programming.
In addition, all Redis keys are binary-safe, which means that almost any kind of data format can be used for the key, including images and audio clips.
Access the redis-cli
redis-cli is a command-line interface which allows you to connect to the Redis server from your terminal or command prompt window:
Once you’ve accessed the Redis CLI, you should see the server’s IP address, which will be
127.0.0.1 if you’re running Redis locally, and port in the prompt:
Data types in Redis
Redis supports the following data types: bitmaps, hashes, lists, sets, sorted sets, strings, ranges, and, perhaps most importantly, key-value data pairs.
Redis strings data type
The string is probably the simplest data type you can associate with a key. In Redis, both a key and a value can take the form of a string. Shown below are some examples of commands involving the string data type in Redis.
The APPEND command in Redis
APPEND command can be used if you already have an existing key value and you’d like to add to that value. The command will simply append the value at the end of the string.
Let’s look at an example:
NOTE: This command returns
0 because the object
keyval doesn’t yet exist.
You can create a new value using the
APPEND command, even if a value doesn’t yet exist prior to executing the command:
127.0.0.1:6379> APPEND keyval "Object"
127.0.0.1:6379> APPEND keyval " rocket"
NOTE: Keep in mind that Redis uses colons (
:) for namespaces. This means that you can use structured keys, such as
SET foo:bar 42, to create a new key-value pair with a structured namespace similar the constructs seen in object-oriented programming languages.
Now, let’s try to output our appended string with the
127.0.0.1:6379> GET keyval
It’s important to make note of the Redis counter pattern– this pattern is used with commands such as
DECRBY. With the counter pattern, an increment command is sent to Redis each time a certain operation occurs. This construct makes it easy to count things like page views or game scores.
Let’s look at an example of some “counter” commands in action:
127.0.0.1:6379> SET keyval "50"
127.0.0.1:6379> INCR keyval
(integer) 51 ## Increments the value of the key by one
127.0.0.1:6379> INCRBY keyval 9
(integer) 60 ## Increase by the number specified of the integer
127.0.0.1:6379> DECR keyval
(integer) 59 ## Decrement the value of the key by one
127.0.0.1:6379> DECRBY keyval 19
(integer) 40 ## Decrease by the number specified of the integer
Redis range data type
range data type is used to obtain a substring of a string, given a certain offset as a starting point. The
GETRANGE command handles the requests, limiting the range of the results to the actual string length.
Here’s an example:
127.0.0.1:6379> SET mkey "The Redis Data Types"
127.0.0.1:6379> GETRANGE mkey 0 4
127.0.0.1:6379> GETRANGE mkey 0 5
127.0.0.1:6379> GETRANGE mkey -5 -1
127.0.0.1:6379> GETRANGE mkey 0 -1
"The Redis Data Types"
SETRANGEcommand is used to overwrite the current value of the string stored in a key. When using this command, an offset must be specified. This offset must fit the length of the string that will be overwriting the original string.
127.0.0.1:6379> SETRANGE mkey 15 "String"
127.0.0.1:6379> GET mkey
"The Redis Data String"
- If you’re dealing with extremely large datasets, using bitwise commands such as
GETBITcan speed up the filtering of data tremendously.
Here’s an example of how to use the
127.0.0.1:6379> SETBIT mkey 6 1
127.0.0.1:6379> GETBIT mkey 0
127.0.0.1:6379> GETBIT mkey 5
127.0.0.1:6379> GETBIT mkey 500
127.0.0.1:6379> GETBIT mkey 3
127.0.0.1:6379> GETBIT mkey 6
Get the data type in Redis
To get the data type for an object or variable in Redis, you can use the
TYPE command. The following example shows the
TYPE command in action:
This command should return:
When you’re finished testing commands in
redis-cli, just type
exit and press return to quit the interface and return back to your terminal prompt.
If you want to harness the full power of Redis, it’s important to understand the data types used in this key-value store. Redis supports a variety of data types, including strings, hashes and lists. In this article, we looked at a few data types and reviewed some examples of how to use them. Check out the second installment of this article series for more information on the Redis data types.
Pilot the ObjectRocket Platform Free!
Try Fully-Managed CockroachDB, Elasticsearch, MongoDB, PostgreSQL (Beta) or Redis.Get Started