Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/jsiqbal/redis
Complete redis course by stephen grider
https://github.com/jsiqbal/redis
hyperloglog redis redis-hash redis-sets redis-string session sort sorted-sets sveltkit
Last synced: about 4 hours ago
JSON representation
Complete redis course by stephen grider
- Host: GitHub
- URL: https://github.com/jsiqbal/redis
- Owner: JsIqbal
- Created: 2024-06-20T06:51:45.000Z (5 months ago)
- Default Branch: master
- Last Pushed: 2024-10-27T19:56:38.000Z (10 days ago)
- Last Synced: 2024-10-28T00:15:33.805Z (10 days ago)
- Topics: hyperloglog, redis, redis-hash, redis-sets, redis-string, session, sort, sorted-sets, sveltkit
- Language: Svelte
- Homepage:
- Size: 289 KB
- Stars: 2
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# create-svelte
Everything you need to build a Svelte project, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/master/packages/create-svelte).
## Creating a project
If you're seeing this, you've probably already done this step. Congrats!
```bash
# create a new project in the current directory
npm init svelte@next
# create a new project in my-app
npm init svelte@next my-app
```
> Note: the `@next` is temporary
## Developing
Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
```bash
npm run dev
# or start the server and open the app in a new browser tab
npm run dev -- --open
```
## Building
To create a production version of your app:
```bash
npm run build
```
You can preview the production build with `npm run preview`.
> To deploy your app, you may need to install an [adapter](https://kit.svelte.dev/docs/adapters) for your target environment.
---
### Section 1: Get started here
- redis is a database faster than treditional databases.
- redis is faster because it uses the ram.
- radis stores data in simple data structures.
- redis has a small number of feature set
#### Instructions:
- create a redis in redis.com
- create a free subscription
- create a new database
- connect the database in rbook.cloud
##### Simple command testing:
```bash
SET key value
```
---
### Section 2: Commands for Adding and Querying data
#### Strings:
- set string:
```bash
SET message "Hellow World!"
```
- get string:
```bash
GET message
```
- Check out the commands from redis official docs
- see the diagrams in section 2
- `GET`: get a value using key: `GET message`
- `NX`: create if the key doesn't exist yet : `SET color blue NX / SETNX color blue`
- `EX`: remove the record after limit time : `SETEX message 2 "Hello World!"`
- `MSET`: multiple set values for keys : `MSETNX colofgsdr blue moshfdel toyota`
- `MGET`: multiple get values for keys : `MGET colofgsdr moshfdel`
- `DEL`: deletes the key: `DEL message`
- `GETRANGE`: gets a string upon (start index - end index) position
- `SETRANGE`: sets a string upon from index value: SETRANGE model 2 bule
- using radis we can make robust minimized datas and retrieve them faster as well
#### Numbers:
- `SET`: set a number : `SET key 1`
- INCR: increament a key with 1 : `INCR key`
- `DECR`: decrement a key with 1 : `DECR key`
- `INCRBY`: increament a number by given limit : `INCRBY key 10`
- `DECRBY`: decrement a number by given limit : `DECRBY key 5`
- `INCRBYFLOAT`: increament a number float wise limit : `INCRBYFLOAT key -2.55`
* Redis is synchronous and single threaded by nature.
---
### Section 3: E-commerce App Setup
### Law of caching:
#### Redis Design Methodology:
- Figure out what queries we need to answer
- Structure data to best answer those queries
#### Key naming conventions:
- Keys should be unique
- Other engineers should understand what a key is for
- Tip - use functions to generate your key names so you never make a typo
- Extremely common practice is to use a ':' to separate different parts of the key
- Small twist on common practice - we are going to use a # before unique ID's to make implementing search easier : users#45
### Section 4: Local redis Setup
#### Install docker desktop
- run
```bash
docker run -d --name redis-stack-server -p 6379:6379 redis/redis-stack-server:latest
```
- moderate
```bash
docker exec -it redis-stack-server redis-cli
```
- connection for local redis with rbay:
```env
REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_PW=
```
- If you want to connect RBook to your local copy of Redis, you will need to run RBook locally.
- To run RBook locally, run npx rbook at your terminal.
- Navigate to localhost:3050
- Open the connection settings window
- Enter a host of 'localhost'
- Enter a port of 6379
- Leave the password blank
- When running RBook locally, any notebooks you create will be added to the folder you ran npx rbook in.
---
### Section 5: Hash Data Structures
#### Initial:
- A hash in redis can be an object of key value pairs but they will not be deeply nested:
- will work:
```json
{
"name": "IQ & CO.",
"created": 1989,
"industry": "Technology"
}
```
- in redis hashes there can only be number and strings as value for the keys
- `HSET`: set multiple key value pare under a mother key : `HSET company name iq industry tech age 12.3 estd 1945`
- `HGET`: get a single key value : `HGET compnay industry`
- `HGETALL`: gets all the key values from a mother key : `HGETALL company`
- `HEXISTS`: checks if a key under monther key exists: `HEXISTS company age`
- `DEL`: deleted all the key value pair under a mother key: `DEL company`
- `HDEL`: deletes a single key value under mother key : `HDEL company age`
- `HINCRBY`: increament a certain key's value under mother key which must be an integer : `HINCRBY company estd 10`
- `HINCRBYFLOAT`: increament a certain key's value under mother key which must be an float : `HINCRBYFLOAT company a 10.5`
- `HSTRLEN`: gives the length of the value under a key under mother key : `HSTRLEN company industry`
- `HKEYS`: gives all the keys under the mother key: `HKEYS company`
- `HVALS`: gives all the values under all the keys under the mother key : `HVALS company`
- `HMSET`: can set a new key and value under the mother key: `HMSET company newKey "new value"` [The same can be achieved using HINCRBY]
### Section 6: Redis has gotchas!
- please check out the file in sandbox: index.ts
### Section 7: Powerful design pattern
- SQL Database Design Methodology
- Put the data in tables
- Figure out how we will query it
- Redis Design Methodology
- Figure out what queries we need to answer
- Structure data to best answer those queries
- Reasons to Store as Hash
- The record has many attributes
- A collection of these records have to be sorted many different ways
- Often need to access a single record at a time
- Don't Use Hashes When...
- The record is only for counting or enforcing uniqueness
- Record stores only one or two attributes
- Used only for creating relations between different records
- The record is only used for time series data
---
### Section 8: Pipelining commands
- Redis does not give power to fetch multiple hashes(IDs) in one single command
- Possible solutions [1]:
- Loop through the Ids and execute HGETALL and get the records one by one.
- We create a hash for each id and execute the HGETALL command each time of creating the id. meaning:
- the loop is running
- the loop is creating hash
- the loop is executing individual command
- !!! THIS IS NOT EFFECIENT
- Possible solutions [2]:
- We create batch of command using loop
- we execute HGETALL command for all the ids in one go.
- we create hash with ids in a loop but
- we tell the loop not to send the request to redis yet
- we complete the loop
- we complete creating the batch of HGETALL
- we give the list of request to redis
- redis gives us a list of records
---
### Section 9: Enforcing uniqueness with set
- Redis has a special feature called set
- In set:
- [SADD] we can add unique value in a set
- If we keep adding the same value its not going to be added in the set
* Example:
- `SADD`: Add a unique value with a key: `SADD name Iqbal` -> will return 1 -> Its going to add iqbal to a set of name.
- if we try to add `SADD name Iqbal` -> will return 0 -> Its not going to add any value in the key of name.
- [SUNION] we can keep and show the same values existing in saparate sets
- `SADD colors:1 red blue green`
- `SADD colors:2 yellow purple green`
- `SADD colors:3 shen green ken`
- `SUNION colors:1 colors:2 colors:3` -> will give us the combined values of unions from the sets:
- [
"red",
"blue",
"green",
"yellow",
"purple",
"white",
"shen",
"ren",
"ken"
]
- `SINTER colors:1 colors:2 colors:3` -> will give us only the common value from all the sets
- [
"blue"
]
- `SDIFF colors:1 colors:2 colors:3` -> will only give us the unique value that only exist in x but not in n numbers in sets.
- [
"red"
]
- `SINTERSTORE color:result colors:1 colors:2 colors:3` -> will store the common values in a new key
- `SMEMBERS color:result` -> will show the values stored in the new key
[
"blue",
"green"
]
- `SISMENBER color:result blue` -> will give 1 if blue exists on color:result key and 0 if not exist
- `SMISMEMBER color:result blue green` -> will give us an array of true and false.
- [
1,
1
]
- `SCARD color:result` -> this gives the number of elements in a key
- `SSCAN colors:1 0 COUNT 2` -> this gives the paginated data. 0 is the page number in here. 2 is the number of element to show in a page.
* - Use cases for SETS of Redis:
- Enforcing uniqueness of any value : suppose a user wants to register but in our cache we have the user already registered.
- Creating a relationship between different records:
- Finding common attributes between different things: SINTER to see the common items liked by 2 users.
- General list of elements where order doesn't matter:
---
### Section 10: Implementing sets
---
### Section 11: Sorted SET
- Redis has a special feature called Sorted set
- In sorted set all the members are sorted from low to high. 0 1 2 3 4 5....
- Sorted Set:
- `ZADD` is used to add a member-score pair to a sorted set. The command is a little unusual
- you first provide the score _then_ the member: `ZADD products 45 monitor`
- `ZSCORE` returns the score of a member: `ZSCORE products monitor`
- `ZREM` removes a member-value pair: `ZREM products monitor`
* Reference:
```REDIS
DEL products
ZADD products 45 cpu
ZADD products 10 keyboard
ZADD products 55 power
ZCARD products
```
- `ZCARD` returns the total number of members in a sorted set: `ZCARD products` => 3.
- `ZCOUNT` is very similar to `ZCARD`, but includes from filtering criteria.
You can use `ZCOUNT` to find the number of members between a range of two scores. By default, these scores are _inclusive_.
There is a variation on the score syntax. Adding in an opening paren before a score (E.g. `(45`) changes the comparison to 'greater than' when applied to the lower bounds, or 'less than' when applied to the upper bound.
You can also use `-inf` or `+inf` to specify negative or positive infinity, respectively.
- `ZCOUNT -inf 55` => 3
- `ZPOPMIN` removes and returns the member with the lowest score: `ZPOPMIN products 3` => ["keyboard","10","cpu","45","power","55"]
- `ZPOPMAX` removes and returns the member with the greatest score: `ZPOPMAX products 2` => ["power","55","cpu","45"]
- `ZINCRBY` adjusts the score of an existing member-score pair: `ZINCRBY products 15 cpu` => "60"
- Provide a negative number to subtract from a score: `ZINCRBY products -15 cpu` => "30"
- New key with value can also be added using `ZINCRBY`: `ZINCRBY products -15 x` => "-15"
- `ZRANGE` Filter the set and find value from 0-60 and limit the result from index 1-3: `ZRANGE products 0 60 BYSCORE LIMIT 0 3` => ["keyboard","cpu","power"]
- also can be applied using `WITHSCORE` `-inf` `+inf` `(45` `45)`
- `REV`: will reverse the current set and after that will apply other commands to the set
---
### Section 12: Sorted SET Implementation
- Sorted set are needed for relationships between different sets in redis
- By using sorted set we can achieve Normalization of DB in Redis
---
### Section 13: Sort Data structure
- A special kind of data structure in redis.
- Normally a hash stores data as key value pair.
- A sorted set stores as members and score.
* but a `SCORE` data structure in redis sorts using the members of the `set`, `sorted set` or `list`!
- first create some sets and sorted sets:
```bash
HSET books:good title 'Good Book' year 1950
HSET books:bad title 'Bad Book' year 1930
HSET books:ok title 'Ok Book' year 1940
ZADD books:likes 999 good
ZADD books:likes 0 bad
ZADD books:likes 40 ok
```
then apply ->
- SORT:
- `SORT books:likes ALPHA` : stores the members of the sorted set alphabetically and sends back the response:
```bash
[
"bad",
"good",
"ok"
]
```
- `SORT books:likes LIMIT 1 2 ALPHA` : stores the members of the sorted set alphabetically and sends back the response, skip the first element and give the next 2 element of the sort:
```bash
[
"good",
"ok"
]
```
- `SORT books:likes BY books:*->year ` :
- breakdown of the command:
- first replace the \* with the member from the sorted set : books:good
- scan redis for the key books:good
- if the key exists then find the value with the year: books:good has year 1950 in it.
- create a volatile set with key value structure like:
```bash
good - 1950
bad - 1930
ok - 1940
```
- BY means sort the set by descending order like:
```bash
bad - 1930
ok - 1940
good - 1950
```
response from redis:
```bash
[
"bad",
"ok",
"good"
]
```
- `SORT books:likes BY books:*->year GET books:*->title` :
- breakdown of the command:
- first replace the \* with the member from the sorted set : books:good
- scan redis for the key books:good
- if the key exists then find the value with the year: books:good has year 1950 in it.
- create a volatile set with key value structure like:
```bash
good - 1950
bad - 1930
ok - 1940
```
- BY means sort the set by descending order like:
```bash
bad - 1930
ok - 1940
good - 1950
```
- `GET books:*->title`:
- again scan redis and find the books:good and return the title of the book
- use sorting criteria from BY year
response from redis:
```bash
[
"Bad Book",
"Ok Book",
"Good Book"
]
```
- More examples:
```bash
SORT books:likes BY books:*->year
GET books:*->title
GET books:*->year
```
- response:
```bash
[
"Bad Book",
"1930",
"Ok Book",
"1940",
"Good Book",
"1950"
]
```
- in here # means also give the name of the member with associated record
```bash
SORT books:likes BY books:*->year
GET #
GET books:*->title
GET books:*->year
```
- response:
```bash
[
"bad",
"Bad Book",
"1930",
"ok",
"Ok Book",
"1940",
"good",
"Good Book",
"1950"
]
```
- in here `nosort` means give the associated record but not based on any sorting criteria:
```bash
SORT books:likes BY nosort
GET #
GET books:*->title
GET books:*->year
```
- response:
```bash
[
"bad",
"Bad Book",
"1930",
"ok",
"Ok Book",
"1940",
"good",
"Good Book",
"1950"
]
```
- SORT has some more options attached to it. You should checkout the .d.ts file of the command!
---
### Section 14: HyperLogLog data structure
- This is a data structure that remembers a value under a key by using complex algorithm but not storing the data.
- `PFADD` Adds a string value under a key: `PFADD vegetable celery` => 1 `e.g: 0 if already exists`
- `PFCOUNT` Tells how many value are there in a key: `PFCOUNT vegetable` => 1 `e.g: 0 if already exists`
* use cases:
- remembering how many view a product or item has
- using in types of data that are not so important to be consistent
- only 12kb ob static memory for even millions of view for an item.
---
### Section 15: List data structure
- This is not an array
- This is a doubly linked list
Typically we use list to keep time series data or data in order like : weather data.