7 |
8 |
9 | [RediSearch](https://redisearch.io) is a real-time indexing and search engine.
10 |
11 | This project will let you discover the new major release (2.0) and see how to use it, in your application.
12 |
13 | 1. [Introduction](docs/001-introduction.md) (2mn)
14 | 1. [Install RediSearch 2.0 & Insert Data](docs/002-install-redisearch.md) (2mn)
15 | 1. [Create Index](docs/003-create-index.md) (5mn)
16 | 1. [Query Data](docs/004-query-data.md) (15mn)
17 | 1. [Manage Indexes](docs/005-manage-index.md) (5mn)
18 | 1. [Import Sample Dataset](docs/006-import-dataset.md) (2mn)
19 | 1. [Querying the Movie Dataset](docs/007-query-movies.md) (20mn)
20 | 1. [Aggregation](docs/008-aggregation.md) (15mn)
21 | 1. [Advanced Options](docs/009-advanced-features.md) (5mn)
22 | 1. [Sample Application](docs/010-application-development.md)
23 |
24 |
25 |
--------------------------------------------------------------------------------
/docs/001-introduction.md:
--------------------------------------------------------------------------------
1 | # Introduction
2 |
3 | In this tutorial you will learn how to use the [redis-stack](https://redis.io/docs/stack/get-started/install/docker/) image to use the [redisearch module](https://redis.io/docs/stack/search/) that provides an indexing and full text search engine for Redis.
4 |
5 | RediSearch provides a simple and fast way to index and query data using any field (secondary index), and do search and aggregation on an indexed dataset.
6 |
7 | ---
8 | Next: [Install RediSearch 2.0 & Insert Data](002-install-redisearch.md)
9 |
--------------------------------------------------------------------------------
/docs/002-install-redisearch.md:
--------------------------------------------------------------------------------
1 | # Install RediSearch
2 |
3 | You have multiple ways to run RediSearch:
4 |
5 | * building from [sources](https://github.com/RediSearch/RediSearch) and installing it inside an existing Redis Instance
6 | * using [Redis Cloud](https://redislabs.com/redis-enterprise-cloud/) _(when RediSearch module 2.0 available)_
7 | * using [Redis Enterprise](https://redislabs.com/redis-enterprise-software/) _(when RediSearch module 2.0 available)_
8 | * using [Docker](https://hub.docker.com/r/redis/redis-stack)
9 |
10 | Let's use Docker for now.
11 |
12 | **1.1 Open a terminal an run the following command**
13 |
14 |
15 | ```
16 | > docker run -it --rm --name redis-stack \
17 | -p 6379:6379 \
18 | redis/redis-stack:latest
19 | ```
20 |
21 | *Note: The container will automatically be removed when it exits (`--rm` parameter).*
22 |
23 | You have now a Redis instance running with RediSearch installed, let's discover the basics.
24 |
25 |
26 | ---
27 | Next: [Create Index](003-create-index.md)
28 |
--------------------------------------------------------------------------------
/docs/003-create-index.md:
--------------------------------------------------------------------------------
1 | # Create Index
2 |
3 | Before creating the index let's describe the dataset and insert entries.
4 |
5 | ## Sample Dataset
6 |
7 | In this project you will use a simple dataset describing movies, for now, all records are in English. You will learn more about other languages in another tutorial.
8 |
9 | A movie is represented by the following attributes:
10 |
11 | * **`movie_id`** : The unique ID of the movie, internal to this database
12 | * **`title`** : The title of the movie.
13 | * **`plot`** : A summary of the movie.
14 | * **`genre`** : The genre of the movie, for now a movie will only have a single genre.
15 | * **`release_year`** : The year the movie was released as a numerical value.
16 | * **`rating`** : A numeric value representing the public's rating for this movie.
17 | * **`votes`** : Number of votes.
18 | * **`poster`** : Link to the movie poster.
19 | * **`imdb_id`** : id of the movie in the [IMDB](https://imdb.com) database.
20 |
21 |
22 | ### Key and Data structure
23 |
24 | As a Redis developer, one of the first things to look when building your application is to define the structure of the key and data (data design/data modeling).
25 |
26 | A common way of defining the keys in Redis is to use specific patterns in them. For example in this application where the database will probably deal with various business objects: movies, actors, theaters, users, ... we can use the following pattern:
27 |
28 | * `business_object:key`
29 |
30 | For example:
31 | * `movie:001` for the movie with the id 001
32 | * `user:001` the user with the id 001
33 |
34 |
35 | and for the movies information you should use a Redis [Hash](https://redis.io/topics/data-types#hashes).
36 |
37 | A Redis Hash allows the application to structure all the movie attributes in individual fields; also RediSearch will index the fields based on the index definition.
38 |
39 | ## Insert Movies
40 |
41 |
42 | It is time now to add some data into your database, let's insert a few movies, using `redis-cli` or [Redis Insight](https://redislabs.com/redisinsight/).
43 |
44 | Once you are connected to your Redis instance run the following commands:
45 |
46 | ```
47 |
48 | > HSET movie:11002 title "Star Wars: Episode V - The Empire Strikes Back" plot "After the Rebels are brutally overpowered by the Empire on the ice planet Hoth, Luke Skywalker begins Jedi training with Yoda, while his friends are pursued by Darth Vader and a bounty hunter named Boba Fett all over the galaxy." release_year 1980 genre "Action" rating 8.7 votes 1127635 imdb_id tt0080684
49 |
50 | > HSET movie:11003 title "The Godfather" plot "The aging patriarch of an organized crime dynasty transfers control of his clandestine empire to his reluctant son." release_year 1972 genre "Drama" rating 9.2 votes 1563839 imdb_id tt0068646
51 |
52 | > HSET movie:11004 title "Heat" plot "A group of professional bank robbers start to feel the heat from police when they unknowingly leave a clue at their latest heist." release_year 1995 genre "Thriller" rating 8.2 votes 559490 imdb_id tt0113277
53 |
54 | > HSET "movie:11005" title "Star Wars: Episode VI - Return of the Jedi" genre "Action" votes 906260 rating 8.3 release_year 1983 plot "The Rebels dispatch to Endor to destroy the second Empire's Death Star." ibmdb_id "tt0086190"
55 |
56 | ```
57 |
58 | Now it is possible to get information from the hash using the movie ID. For example if you want to get the title, and rating execute the following command:
59 |
60 | ```
61 | > HMGET movie:11002 title rating
62 |
63 | 1) "Star Wars: Episode V - The Empire Strikes Back"
64 | 2) "8.7"
65 | ```
66 |
67 | And you can increment the rating of this movie using:
68 |
69 | ```
70 | > HINCRBYFLOAT movie:11002 rating 0.1
71 | "8.8"
72 | ```
73 |
74 | But how do you get a movie or list of movies by year of release, rating or title?
75 |
76 | One option, would be to read all the movies, check all fields and then return only matching movies; no need to say that this is a really bad idea.
77 |
78 | Nevertheless this is where Redis developers often create custom secondary indexes using SET/SORTED SET structures that point back to the movie hash. This needs some heavy design and implementation.
79 |
80 | This is where the RediSearch module can help, and why it was created.
81 |
82 |
83 | ## RediSearch & Indexing
84 |
85 |
86 | RediSearch greatly simplifies this by offering a simple and automatic way to create secondary indices on Redis Hashes. (more datastructure will eventually come)
87 |
88 | 
89 |
90 | Using RediSearch if you want to query on a field, you must first index that field. Let's start by indexing the following fields for our movies:
91 |
92 | * Title
93 | * Release Year
94 | * Rating
95 | * Genre
96 |
97 | When creating a index you define:
98 |
99 | * which data you want to index: all *hashes* with a key starting with `movies`
100 | * which fields in the hashes you want to index using a Schema definition.
101 |
102 | > ***Warning: Do not index all fields***
103 | >
104 | > Indexes take space in memory, and must be updated when the primary data is updated. So create the index carefully and keep the definition up to date with your needs.
105 |
106 | ### Create the Index
107 |
108 | Create the index with the following command:
109 |
110 | ```
111 | > FT.CREATE idx:movie ON hash PREFIX 1 "movie:" SCHEMA title TEXT SORTABLE release_year NUMERIC SORTABLE rating NUMERIC SORTABLE genre TAG SORTABLE
112 | ```
113 |
114 | Before running some queries let's look at the command in detail:
115 |
116 | * [`FT.CREATE`](https://oss.redislabs.com/redisearch/master/Commands/#ftcreate) : creates an index with the given spec. The index name will be used in all the key names so keep it short.
117 | * `idx:movie` : the name of the index
118 | * `ON hash` : the type of structure to be indexed. *Note that in RediSearch 2.0 only hash structures are supported, this parameter will accept other Redis data types in future as RediSearch is updated to index them*
119 | * `PREFIX 1 "movie:"` : the prefix of the keys that should be indexed. This is a list, so since we want to only index movie:* keys the number is 1. Suppose you want to index movies and tv_show that have the same fields, you can use: `PREFIX 2 "movie:" "tv_show:"`
120 | * `SCHEMA ...`: defines the schema, the fields and their type, to index, as you can see in the command, we are using [TEXT](https://oss.redislabs.com/redisearch/Query_Syntax/#a_few_query_examples), [NUMERIC](https://oss.redislabs.com/redisearch/Query_Syntax/#numeric_filters_in_query) and [TAG](https://oss.redislabs.com/redisearch/Query_Syntax/#tag_filters), and [SORTABLE](https://oss.redislabs.com/redisearch/Sorting/) parameters.
121 |
122 | You can find information about the [FT.CREATE](https://oss.redislabs.com/redisearch/Commands/#ftcreate) command in the [documentation](https://oss.redislabs.com/redisearch/Commands/#ftcreate).
123 |
124 |
125 | You can look at the index information with the following command:
126 |
127 | ```
128 | > FT.INFO idx:movie
129 | ```
130 |
131 | ---
132 | Next: [Query Data](004-query-data.md)
133 |
--------------------------------------------------------------------------------
/docs/004-query-data.md:
--------------------------------------------------------------------------------
1 | # Query Data
2 |
3 | The database contains a few movies, and an index, it is now possible to execute some queries.
4 |
5 | ## Queries
6 |
7 | **Example : *All the movies that contains the string "`war`"***
8 |
9 | ```
10 | > FT.SEARCH idx:movie "war"
11 |
12 | 1) (integer) 2
13 | 2) "movie:11005"
14 | 3) 1) "title"
15 | 2) "Star Wars: Episode VI - Return of the Jedi"
16 | ...
17 | 14) "tt0086190"
18 | 4) "movie:11002"
19 | 5) 1) "title"
20 | 2) "Star Wars: Episode V - The Empire Strikes Back"
21 | ...
22 | 13) "imdb_id"
23 | 14) "tt0080684"
24 |
25 | ```
26 |
27 | The FT.SEARCH commands returns a list of results starting with the number of results, then the list of elements (keys & fields).
28 |
29 | As you can see the movie *Star Wars: Episode V - The Empire Strikes Back* is found, even though you used only the word “war” to match “Wars” in the title. This is because the title has been indexed as text, so the field is [tokenized](https://oss.redislabs.com/redisearch/Escaping/) and [stemmed](https://oss.redislabs.com/redisearch/Stemming/).
30 |
31 | Later when looking at the query syntax in more detail you will learn more about the search capabilities.
32 |
33 | It is also possible to limit the list of fields returned by the query using the `RETURN` parameter, let's run the same query, and return only the title and release_year:
34 |
35 | ```
36 | > FT.SEARCH idx:movie "war" RETURN 2 title release_year
37 |
38 | 1) (integer) 2
39 | 2) "movie:11005"
40 | 3) 1) "title"
41 | 2) "Star Wars: Episode VI - Return of the Jedi"
42 | 3) "release_year"
43 | 4) "1983"
44 | 4) "movie:11002"
45 | 5) 1) "title"
46 | 2) "Star Wars: Episode V - The Empire Strikes Back"
47 | 3) "release_year"
48 | 4) "1980"
49 | ```
50 |
51 | This query does not specify any "field" and still returns some movies, this is because RediSearch will search all TEXT fields by default. In the current index only the title is present as a TEXT field. You will see later how to update an index, to add more fields to it.
52 |
53 | If you need to perform a query on a specific field you can specify it using the `@field:` syntax, for example:
54 |
55 | ```
56 | > FT.SEARCH idx:movie "@title:war" RETURN 2 title release_year
57 | ```
58 |
59 | ---
60 | **Example : *All the movies that contains the string "`war` but NOT the `jedi` one"***
61 |
62 | Adding the string `-jedi` (minus) will ask the query engine not to return values that contain `jedi`.
63 |
64 | ```
65 | > FT.SEARCH idx:movie "war -jedi" RETURN 2 title release_year
66 |
67 | 1) (integer) 1
68 | 2) "movie:11002"
69 | 3) 1) "title"
70 | 2) "Star Wars: Episode V - The Empire Strikes Back"
71 | 3) "release_year"
72 | 4) "1980"
73 | ```
74 |
75 | ---
76 | **Example : *All the movies that contains the string "`gdfather` using fuzzy search"***
77 |
78 | As you can see the word godfather contains a speelling error, it can however be matched using [fuzzy matching](https://oss.redislabs.com/redisearch/Query_Syntax/#fuzzy_matching). Fuzzy matches are performed based on [Levenshtein distance](https://en.wikipedia.org/wiki/Levenshtein_distance) (LD).
79 |
80 | ```
81 | > FT.SEARCH idx:movie " %gdfather% " RETURN 2 title release_year
82 |
83 | 1) (integer) 1
84 | 2) "movie:11003"
85 | 3) 1) "title"
86 | 2) "The Godfather"
87 | 3) "release_year"
88 | 4) "1972"
89 | ```
90 |
91 | ---
92 | **Example : *All `Thriller` movies"***
93 |
94 | The `genre` fields is indexed as a TAG and allows exact match queries.
95 |
96 | The syntax to query a TAG field is @field_name:{value}
97 |
98 | ```
99 | > FT.SEARCH idx:movie "@genre:{Thriller}" RETURN 2 title release_year
100 |
101 | 1) (integer) 1
102 | 2) "movie:11004"
103 | 3) 1) "title"
104 | 2) "Heat"
105 | 3) "release_year"
106 | 4) "1995"
107 |
108 | ```
109 |
110 | ---
111 | **Example : *All `Thriller` or `Action` movies"***
112 |
113 | ```
114 | > FT.SEARCH idx:movie "@genre:{Thriller|Action}" RETURN 2 title release_year
115 |
116 | 1) (integer) 3
117 | 2) "movie:11004"
118 | 3) 1) "title"
119 | 2) "Heat"
120 | 3) "release_year"
121 | 4) "1995"
122 | 4) "movie:11005"
123 | 5) 1) "title"
124 | 2) "Star Wars: Episode VI - Return of the Jedi"
125 | 3) "release_year"
126 | 4) "1983"
127 | 6) "movie:11002"
128 | 7) 1) "title"
129 | 2) "Star Wars: Episode V - The Empire Strikes Back"
130 | 3) "release_year"
131 | 4) "1980"
132 | ```
133 |
134 | You can find more information about the Tag filters in [the documentation](https://redis.io/docs/stack/search/reference/query_syntax/#tag-filters).
135 |
136 | ---
137 | **Example : *All `Thriller` or `Action` movies that does not have `Jedi` in the title"***
138 |
139 | ```
140 | > FT.SEARCH idx:movie "@genre:{Thriller|Action} @title:-jedi" RETURN 2 title release_year
141 |
142 | 1) (integer) 2
143 | 2) "movie:11004"
144 | 3) 1) "title"
145 | 2) "Heat"
146 | 3) "release_year"
147 | 4) "1995"
148 | 4) "movie:11002"
149 | 5) 1) "title"
150 | 2) "Star Wars: Episode V - The Empire Strikes Back"
151 | 3) "release_year"
152 | 4) "1980"
153 | ```
154 |
155 | ---
156 | **Example : *All the movies released between 1970 and 1980 (included)***
157 |
158 | The FT.SEARCH syntax has two ways to query numeric fields:
159 |
160 | * using the `FILTER` parameter
161 |
162 | or
163 |
164 | * using the `@field` in the query string.
165 |
166 |
167 | ```
168 | > FT.SEARCH idx:movie * FILTER release_year 1970 1980 RETURN 2 title release_year
169 | ```
170 |
171 | ```
172 | > FT.SEARCH idx:movie "@release_year:[1970 1980]" RETURN 2 title release_year
173 |
174 | 1) (integer) 2
175 | 2) "movie:11003"
176 | 3) 1) "title"
177 | 2) "The Godfather"
178 | 3) "release_year"
179 | 4) "1972"
180 | 4) "movie:11002"
181 | 5) 1) "title"
182 | 2) "Star Wars: Episode V - The Empire Strikes Back"
183 | 3) "release_year"
184 | 4) "1980"
185 |
186 | ```
187 |
188 | To exclude a value prepend it with `(` in the FILTER or query string, for example to exclude 1980:
189 |
190 | ```
191 | > FT.SEARCH idx:movie "@release_year:[1970 (1980]" RETURN 2 title release_year
192 | ```
193 |
194 | ---
195 | ## Insert, Update, Delete and Expire Documents
196 |
197 | As part of this tutorial you have:
198 |
199 | 1. Created few movies, as Redis hashes (*that we call document*) with the following key pattern `movie:*`
200 | 2. Created an index using the `FT.CREATE` command
201 | 3. Queried the data using `FT.SEARCH`
202 |
203 | When creating the index, using the `idx:movie ON hash PREFIX 1 "movie:"` parameter you are asking the indexing engine to look at all existing keys and index them.
204 |
205 | Also new information that matches this pattern/type, will be indexed.
206 |
207 | Let's count the number of movies, add a new one, and count again:
208 |
209 | ```
210 | > FT.SEARCH idx:movie "*" LIMIT 0 0
211 |
212 | 1) (integer) 4
213 |
214 |
215 | > HSET movie:11033 title "Tomorrow Never Dies" plot "James Bond sets out to stop a media mogul's plan to induce war between China and the U.K in order to obtain exclusive global media coverage." release_year 1997 genre "Action" rating 6.5 votes 177732 imdb_id tt0120347
216 |
217 | > FT.SEARCH idx:movie "*" LIMIT 0 0
218 |
219 | 1) (integer) 5
220 |
221 | ```
222 |
223 | The new movie has been indexed. You can also search on any of the indexed fields:
224 |
225 | ```
226 | > FT.SEARCH idx:movie "never" RETURN 2 title release_year
227 |
228 | 1) (integer) 1
229 | 2) "movie:11033"
230 | 3) 1) "title"
231 | 2) "Tomorrow Never Dies"
232 | 3) "release_year"
233 | 4) "1997"
234 | ```
235 |
236 | Now you **update** one of the field, and search for `007`
237 |
238 | ```
239 | > HSET movie:11033 title "Tomorrow Never Dies - 007"
240 |
241 |
242 | > FT.SEARCH idx:movie "007" RETURN 2 title release_year
243 |
244 | 1) (integer) 1
245 | 2) "movie:11033"
246 | 3) 1) "title"
247 | 2) "Tomorrow Never Dies - 007"
248 | 3) "release_year"
249 | 4) "1997"
250 | ```
251 |
252 | When you *delete* the hash, the index is also updated, and the same happens when the key expires (TTL-Time To Live).
253 |
254 | For example, set the James Bond movie to expire in 20 seconds time:
255 |
256 | ```
257 | > EXPIRE "movie:11033" 20
258 |
259 | ```
260 |
261 | You can run the following query, and you will that the document expires after 20 seconds and the search query will not return any results, showing that the index has been updated.
262 |
263 | ```
264 | > FT.SEARCH idx:movie "007" RETURN 2 title release_year
265 |
266 | 1) (integer)
267 |
268 | ```
269 |
270 | > Note: When you are using Redis as your primary database you are not necessarily using TTLs to delete records. However, if the data you are storing and indexing are transient, for example a caching layer at the top of another datastore or Web service, query user sessions content, ... This is often qualified as a "[Ephemeral Search](https://redislabs.com/blog/the-case-for-ephemeral-search/)" use case: lightweight, fast and expiration.
271 |
272 | ---
273 | ## More
274 | You have many additional features regarding indexing and searching that you can find in the documentation:
275 |
276 | * [FT.SEARCH command](https://redis.io/commands/ft.search)
277 | * [Query Syntax](https://redis.io/docs/stack/search/reference/query_syntax/)
278 |
279 |
280 | Let's see how to inspect, modify and drop an index.
281 |
282 | ---
283 | Next: [Manage Indexes](005-manage-index.md)
284 |
--------------------------------------------------------------------------------
/docs/005-manage-index.md:
--------------------------------------------------------------------------------
1 | # Manage Index
2 |
3 |
4 | ### Listing and inspecting the indexes
5 |
6 | The `FT._LIST` command provides a list of all RediSearch indexes in your database:
7 |
8 | ```
9 | > FT._LIST
10 | 1) "idx:movie"
11 | ```
12 |
13 | `FT.INFO` provides information about a specific index:
14 |
15 | ```
16 | > FT.INFO "idx:movie"
17 |
18 | 1) "index_name"
19 | 2) "idx:movie"
20 | ...
21 | 5) "index_definition"
22 | ...
23 | 7) "fields"
24 | ...
25 | 9) "num_docs"
26 | 10) "4"
27 | ...
28 |
29 | ```
30 |
31 |
32 | ### Updating your Indexing
33 |
34 | As you build your application and add more information to the database you may need to add new fields to the index. The `FT.ALTER` command enables you to do this.
35 |
36 | ```
37 | > FT.ALTER idx:movie SCHEMA ADD plot TEXT WEIGHT 0.5
38 | "OK"
39 | ```
40 |
41 | The `WEIGHT` declares the importance of this field when calculating result accuracy. This is a multiplication factor (default is 1); so in this example the plot is less important than the title.
42 |
43 | Let's do a query with the new indexed field:
44 |
45 | ```
46 | > FT.SEARCH idx:movie "empire @genre:{Action}" RETURN 2 title plot
47 |
48 | ```
49 |
50 |
51 | ### Dropping the Index
52 |
53 |
54 | You can drop an index using the `FT.DROPINDEX` command.
55 |
56 | ```
57 | > FT.DROPINDEX idx:movie
58 |
59 | "OK"
60 | ```
61 |
62 | Dropping an index does not impact the indexed hashes, this means that the movies are still inside the database.
63 |
64 | ```
65 | >SCAN 0 MATCH movie:*
66 |
67 | 1) "0"
68 | 2) 1) "movie:11002"
69 | 2) "movie:11004"
70 | 3) "movie:11003"
71 | 4) "movie:11005"
72 | ```
73 |
74 |
75 | *Note: You can delete the indexed document/hashes by adding the `DD` parameter.*
76 |
77 |
78 | ---
79 | Next: [Import Sample Dataset](006-import-dataset.md)
80 |
--------------------------------------------------------------------------------
/docs/006-import-dataset.md:
--------------------------------------------------------------------------------
1 | # Sample Dataset
2 |
3 | In the previous steps you used only a few movies, let's now import:
4 |
5 | * More movies *to discover more queries*.
6 | * Theaters *to discover the geospatial capabilities*.
7 | * Users *to do some aggregations*.
8 |
9 | ## Dataset Description
10 |
11 | **Movies**
12 |
13 | The file `sample-app/redisearch-docker/dataset/import_movies.redis` is a script that creates 922 Hashes.
14 |
15 | The movie hashes contain the following fields.
16 |
17 | * **`movie:id`** : The unique ID of the movie, internal to this database (used as the key of the hash)
18 | * **`title`** : The title of the movie.
19 | * **`plot`** : A summary of the movie.
20 | * **`genre`** : The genre of the movie, for now a movie will only have a single genre.
21 | * **`release_year`** : The year the movie was released as a numerical value.
22 | * **`rating`** : A numeric value representing the public's rating for this movie.
23 | * **`votes`** : Number of votes.
24 | * **`poster`** : Link to the movie poster.
25 | * **`imdb_id`** : id of the movie in the [IMDB](https://imdb.com) database.
26 |
27 | | Field | 33 |Value | 34 |
|---|---|
| title | 39 |40 | Spider-Man 41 | | 42 |
| plot | 45 |46 | When bitten by a genetically modified spider a nerdy shy and awkward high school student gains spider-like abilities that he eventually must use to fight evil as a superhero after tragedy befalls his family. 47 | | 48 |
| genre | 51 |52 | Action 53 | | 54 |
| release_year | 57 |58 | 2002 59 | | 60 |
| rating | 63 |64 | 7.3 65 | | 66 |
| votes | 69 |70 | 662219 71 | | 72 |
| poster | 75 |76 | https://m.media-amazon.com/images/M/MV5BZDEyN2NhMjgtMjdhNi00MmNlLWE5YTgtZGE4MzNjMTRlMGEwXkEyXkFqcGdeQXVyNDUyOTg3Njg@._V1_SX300.jpg 77 | | 78 |
| imdb_id | 81 |82 | tt0145487 83 | | 84 |
| Field | 111 |Value | 112 |
|---|---|
| name | 117 |118 | Broadway Theatre 119 | | 120 |
| address | 123 |124 | 1681 Broadway 125 | | 126 |
| city | 129 |130 | New York 131 | | 132 |
| zip | 135 |136 | 10019 137 | | 138 |
| phone | 141 |142 | 212 944-3700 143 | | 144 |
| url | 147 |148 | http://www.shubertorganization.com/theatres/broadway.asp 149 | | 150 |
| location | 153 |154 | -73.98335054631019,40.763270202723625 155 | | 156 |
| Field | 187 |Value | 188 |
|---|---|
| first_name | 193 |194 | Rosetta 195 | | 196 |
| last_name | 199 |200 | Olyff 201 | | 202 |
| 206 | rolyff6g@163.com 207 | | 208 ||
| gender | 211 |212 | female 213 | | 214 |
| country | 217 |218 | China 219 | | 220 |
| country_code | 223 |224 | CN 225 | | 226 |
| city | 229 |230 | Huangdao 231 | | 232 |
| longitude | 235 |236 | 120.04619 237 | | 238 |
| latitude | 241 |242 | 35.872664 243 | | 244 |
| last_login | 247 |248 | 1570386621 249 | | 250 |
| ip_address | 253 |254 | 218.47.90.79 255 | | 256 |
9 | Tutorial: RediSearch
10 | 
26 | 
38 |
39 | Movie saved
22 |