From 4f1273098ed27623d80738eaedad47da8894d1b3 Mon Sep 17 00:00:00 2001 From: Eric Date: Tue, 17 Jan 2017 09:08:56 -0800 Subject: [PATCH 1/2] Add note on backend choice to secondary index section in dev querying pages --- .../getting-started/csharp/querying.md | 6 +++++ .../getting-started/erlang/querying.md | 6 +++++ .../getting-started/golang/querying.md | 14 +++++++--- .../getting-started/java/querying.md | 8 +++++- .../getting-started/nodejs/querying.md | 6 +++++ .../getting-started/php/querying.md | 22 ++++++++++------ .../getting-started/python/querying.md | 26 ++++++++++++------- .../getting-started/ruby/querying.md | 12 ++++++--- .../getting-started/csharp/querying.md | 6 +++++ .../getting-started/erlang/querying.md | 6 +++++ .../getting-started/golang/querying.md | 14 +++++++--- .../getting-started/java/querying.md | 8 +++++- .../getting-started/nodejs/querying.md | 6 +++++ .../getting-started/php/querying.md | 22 ++++++++++------ .../getting-started/python/querying.md | 26 ++++++++++++------- .../getting-started/ruby/querying.md | 12 ++++++--- .../getting-started/csharp/querying.md | 6 +++++ .../getting-started/erlang/querying.md | 6 +++++ .../getting-started/golang/querying.md | 14 +++++++--- .../getting-started/java/querying.md | 8 +++++- .../getting-started/nodejs/querying.md | 6 +++++ .../getting-started/php/querying.md | 22 ++++++++++------ .../getting-started/python/querying.md | 26 ++++++++++++------- .../getting-started/ruby/querying.md | 12 ++++++--- .../getting-started/csharp/querying.md | 6 +++++ .../getting-started/erlang/querying.md | 6 +++++ .../getting-started/golang/querying.md | 14 +++++++--- .../getting-started/java/querying.md | 8 +++++- .../getting-started/nodejs/querying.md | 6 +++++ .../getting-started/php/querying.md | 22 ++++++++++------ .../getting-started/python/querying.md | 26 ++++++++++++------- .../getting-started/ruby/querying.md | 12 ++++++--- .../getting-started/csharp/querying.md | 6 +++++ .../getting-started/erlang/querying.md | 6 +++++ .../getting-started/golang/querying.md | 14 +++++++--- .../getting-started/java/querying.md | 8 +++++- .../getting-started/nodejs/querying.md | 6 +++++ .../getting-started/php/querying.md | 22 ++++++++++------ .../getting-started/python/querying.md | 26 ++++++++++++------- .../getting-started/ruby/querying.md | 12 ++++++--- .../getting-started/csharp/querying.md | 6 +++++ .../getting-started/erlang/querying.md | 6 +++++ .../getting-started/golang/querying.md | 14 +++++++--- .../getting-started/java/querying.md | 8 +++++- .../getting-started/nodejs/querying.md | 6 +++++ .../getting-started/php/querying.md | 22 ++++++++++------ .../getting-started/python/querying.md | 26 ++++++++++++------- .../getting-started/ruby/querying.md | 12 ++++++--- .../getting-started/csharp/querying.md | 6 +++++ .../getting-started/erlang/querying.md | 6 +++++ .../getting-started/golang/querying.md | 14 +++++++--- .../getting-started/java/querying.md | 8 +++++- .../getting-started/nodejs/querying.md | 6 +++++ .../getting-started/php/querying.md | 22 ++++++++++------ .../getting-started/python/querying.md | 26 ++++++++++++------- .../getting-started/ruby/querying.md | 12 ++++++--- .../getting-started/csharp/querying.md | 6 +++++ .../getting-started/erlang/querying.md | 6 +++++ .../getting-started/golang/querying.md | 14 +++++++--- .../getting-started/java/querying.md | 8 +++++- .../getting-started/nodejs/querying.md | 6 +++++ .../getting-started/php/querying.md | 22 ++++++++++------ .../getting-started/python/querying.md | 26 ++++++++++++------- .../getting-started/ruby/querying.md | 12 ++++++--- .../getting-started/csharp/querying.md | 6 +++++ .../getting-started/erlang/querying.md | 6 +++++ .../getting-started/golang/querying.md | 14 +++++++--- .../getting-started/java/querying.md | 8 +++++- .../getting-started/nodejs/querying.md | 6 +++++ .../getting-started/php/querying.md | 22 ++++++++++------ .../getting-started/python/querying.md | 26 ++++++++++++------- .../getting-started/ruby/querying.md | 12 ++++++--- .../getting-started/csharp/querying.md | 6 +++++ .../getting-started/erlang/querying.md | 6 +++++ .../getting-started/golang/querying.md | 14 +++++++--- .../getting-started/java/querying.md | 8 +++++- .../getting-started/nodejs/querying.md | 6 +++++ .../getting-started/php/querying.md | 22 ++++++++++------ .../getting-started/python/querying.md | 26 ++++++++++++------- .../getting-started/ruby/querying.md | 12 ++++++--- .../getting-started/csharp/querying.md | 6 +++++ .../getting-started/erlang/querying.md | 6 +++++ .../getting-started/golang/querying.md | 14 +++++++--- .../getting-started/java/querying.md | 8 +++++- .../getting-started/nodejs/querying.md | 6 +++++ .../getting-started/php/querying.md | 22 ++++++++++------ .../getting-started/python/querying.md | 26 ++++++++++++------- .../getting-started/ruby/querying.md | 12 ++++++--- 88 files changed, 814 insertions(+), 286 deletions(-) diff --git a/content/riak/kv/2.0.0/developing/getting-started/csharp/querying.md b/content/riak/kv/2.0.0/developing/getting-started/csharp/querying.md index cc5def81ef..ed3327b8ff 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/csharp/querying.md @@ -124,6 +124,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.0/developing/getting-started/erlang/querying.md b/content/riak/kv/2.0.0/developing/getting-started/erlang/querying.md index 5d7f085a09..6c9b31fb22 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/erlang/querying.md @@ -214,6 +214,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.0/developing/getting-started/golang/querying.md b/content/riak/kv/2.0.0/developing/getting-started/golang/querying.md index 8cabb68956..d7d7f90655 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/golang/querying.md @@ -18,7 +18,7 @@ aliases: ## Go Version Setup -For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix OS. +For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix* OS. >A Quick Note on Querying and Schemas: > @@ -340,7 +340,7 @@ func createOrderSummary(customerId string, orders []*Order) *OrderSummary { } ``` -While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. +While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```golang util.Log.Println("Fetching related data by shared key") @@ -415,6 +415,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: ```golang @@ -496,7 +502,7 @@ wg.Wait() close(doneChan) ``` -As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders. We'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`: @@ -564,7 +570,7 @@ Easy! We used 2i's range feature to search for a range of values, and demonstra So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys. * You can search for specific values or a range of values. * Riak will return a list of keys that match the index query. diff --git a/content/riak/kv/2.0.0/developing/getting-started/java/querying.md b/content/riak/kv/2.0.0/developing/getting-started/java/querying.md index 33c4eb0ee6..d140bde6b9 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/java/querying.md @@ -25,7 +25,7 @@ branch](https://github.com/basho/taste-of-riak/archive/master.zip). The code for this chapter is in `/java/Ch02-Schemas-and-Indexes`. You may import this code into your favorite editor, or just run it from the command line using the commands in `BuildAndRun.sh` if you are running -on a *nix OS. +on a *nix* OS. ## A Quick Note on Querying and Schemas @@ -193,6 +193,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.0/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.0.0/developing/getting-started/nodejs/querying.md index a10d5bfd3e..636a040cf9 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/nodejs/querying.md @@ -86,6 +86,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.0/developing/getting-started/php/querying.md b/content/riak/kv/2.0.0/developing/getting-started/php/querying.md index 9629ee4a12..222b8becac 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/php/querying.md @@ -94,7 +94,7 @@ class Item class OrderSummary { - public function __construct() + public function __construct() { $this->summaries = array(); } @@ -104,7 +104,7 @@ class OrderSummary class OrderSummaryItem { - public function __construct(Order $order) + public function __construct(Order $order) { $this->orderId = $order->orderId; $this->total = $order->total; @@ -141,8 +141,8 @@ $order1->items = [ 15.99 ), new Item( - 'PEG10BBF2PP', - 'eTablet Pro; 24GB; Grey', + 'PEG10BBF2PP', + 'eTablet Pro; 24GB; Grey', 399.99 ) ]; @@ -231,7 +231,7 @@ $storeSummary = (new Command\Builder\StoreObject($riak)) $storeSummary->execute(); ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```php // Fetching related data by shared key @@ -297,6 +297,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```php @@ -323,7 +329,7 @@ unset($key); ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```php @@ -354,7 +360,7 @@ Jane processed orders 1 and 3. We used an "integer" index to reference Jane's i Now, let's say that the VP of Sales wants to know how many orders came in during October 2013. In this case, we can exploit 2i's range queries. Let's search the `order_date_bin` index for entries between `20131001` and `20131031`. ```php -// Query for orders where the OrderDate bin index is +// Query for orders where the OrderDate bin index is // between 2013-10-01 and 2013-10-31 $fetchOctoberOrders = (new Command\Builder\QueryIndex($riak)) ->inBucket($ordersBucket) @@ -392,7 +398,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys (and terms if needed) that match the index query diff --git a/content/riak/kv/2.0.0/developing/getting-started/python/querying.md b/content/riak/kv/2.0.0/developing/getting-started/python/querying.md index 65398a82f4..d8bee38d07 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/python/querying.md @@ -150,7 +150,7 @@ os = order_summary_bucket.new(str(order_summary['customer_id']), os.store() ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```python customer = customer_bucket.get('1').data @@ -162,15 +162,15 @@ Which returns our amalgamated objects: ```python { - u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', - u'created_date': u'2013-10-01 14:30:26', - 'order_summary': { + u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', + u'created_date': u'2013-10-01 14:30:26', + 'order_summary': { u'customer_id': 1, u'summaries': [ - {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, - {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, + {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, + {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, {u'order_id': 3, u'order_date': u'2013-11-03 17:45:28', u'total': 74.98} - ]}, - u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', + ]}, + u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', u'customer_id': 1 } ``` @@ -180,6 +180,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```python @@ -191,7 +197,7 @@ for i in range(1, 4): order.store() ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```python @@ -224,7 +230,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.0.0/developing/getting-started/ruby/querying.md b/content/riak/kv/2.0.0/developing/getting-started/ruby/querying.md index 1b7212672f..8e3a10ea6c 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/ruby/querying.md @@ -149,7 +149,7 @@ os.data = order_summary os.store ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```ruby shared_key = '1' @@ -190,6 +190,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```ruby @@ -206,7 +212,7 @@ If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL ind end ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```ruby @@ -240,7 +246,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.0.1/developing/getting-started/csharp/querying.md b/content/riak/kv/2.0.1/developing/getting-started/csharp/querying.md index 37b8c1f3a8..3428f3932f 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/csharp/querying.md @@ -124,6 +124,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.1/developing/getting-started/erlang/querying.md b/content/riak/kv/2.0.1/developing/getting-started/erlang/querying.md index eb3857eea7..0c5f992e5a 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/erlang/querying.md @@ -214,6 +214,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.1/developing/getting-started/golang/querying.md b/content/riak/kv/2.0.1/developing/getting-started/golang/querying.md index d370c46b97..9d8384b841 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/golang/querying.md @@ -18,7 +18,7 @@ aliases: ## Go Version Setup -For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix OS. +For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix* OS. >A Quick Note on Querying and Schemas: > @@ -340,7 +340,7 @@ func createOrderSummary(customerId string, orders []*Order) *OrderSummary { } ``` -While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. +While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```golang util.Log.Println("Fetching related data by shared key") @@ -415,6 +415,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: ```golang @@ -496,7 +502,7 @@ wg.Wait() close(doneChan) ``` -As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders. We'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`: @@ -564,7 +570,7 @@ Easy! We used 2i's range feature to search for a range of values, and demonstra So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys. * You can search for specific values or a range of values. * Riak will return a list of keys that match the index query. diff --git a/content/riak/kv/2.0.1/developing/getting-started/java/querying.md b/content/riak/kv/2.0.1/developing/getting-started/java/querying.md index 4bd743c368..97d5d6d781 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/java/querying.md @@ -25,7 +25,7 @@ branch](https://github.com/basho/taste-of-riak/archive/master.zip). The code for this chapter is in `/java/Ch02-Schemas-and-Indexes`. You may import this code into your favorite editor, or just run it from the command line using the commands in `BuildAndRun.sh` if you are running -on a *nix OS. +on a *nix* OS. ## A Quick Note on Querying and Schemas @@ -193,6 +193,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.1/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.0.1/developing/getting-started/nodejs/querying.md index 5bf8c1d7ed..1e65e14887 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/nodejs/querying.md @@ -86,6 +86,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.1/developing/getting-started/php/querying.md b/content/riak/kv/2.0.1/developing/getting-started/php/querying.md index d02c727dda..b489300aae 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/php/querying.md @@ -94,7 +94,7 @@ class Item class OrderSummary { - public function __construct() + public function __construct() { $this->summaries = array(); } @@ -104,7 +104,7 @@ class OrderSummary class OrderSummaryItem { - public function __construct(Order $order) + public function __construct(Order $order) { $this->orderId = $order->orderId; $this->total = $order->total; @@ -141,8 +141,8 @@ $order1->items = [ 15.99 ), new Item( - 'PEG10BBF2PP', - 'eTablet Pro; 24GB; Grey', + 'PEG10BBF2PP', + 'eTablet Pro; 24GB; Grey', 399.99 ) ]; @@ -231,7 +231,7 @@ $storeSummary = (new Command\Builder\StoreObject($riak)) $storeSummary->execute(); ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```php // Fetching related data by shared key @@ -297,6 +297,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```php @@ -323,7 +329,7 @@ unset($key); ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```php @@ -354,7 +360,7 @@ Jane processed orders 1 and 3. We used an "integer" index to reference Jane's i Now, let's say that the VP of Sales wants to know how many orders came in during October 2013. In this case, we can exploit 2i's range queries. Let's search the `order_date_bin` index for entries between `20131001` and `20131031`. ```php -// Query for orders where the OrderDate bin index is +// Query for orders where the OrderDate bin index is // between 2013-10-01 and 2013-10-31 $fetchOctoberOrders = (new Command\Builder\QueryIndex($riak)) ->inBucket($ordersBucket) @@ -392,7 +398,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys (and terms if needed) that match the index query diff --git a/content/riak/kv/2.0.1/developing/getting-started/python/querying.md b/content/riak/kv/2.0.1/developing/getting-started/python/querying.md index 68766a8e0f..f2a743a54c 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/python/querying.md @@ -150,7 +150,7 @@ os = order_summary_bucket.new(str(order_summary['customer_id']), os.store() ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```python customer = customer_bucket.get('1').data @@ -162,15 +162,15 @@ Which returns our amalgamated objects: ```python { - u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', - u'created_date': u'2013-10-01 14:30:26', - 'order_summary': { + u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', + u'created_date': u'2013-10-01 14:30:26', + 'order_summary': { u'customer_id': 1, u'summaries': [ - {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, - {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, + {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, + {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, {u'order_id': 3, u'order_date': u'2013-11-03 17:45:28', u'total': 74.98} - ]}, - u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', + ]}, + u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', u'customer_id': 1 } ``` @@ -180,6 +180,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```python @@ -191,7 +197,7 @@ for i in range(1, 4): order.store() ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```python @@ -224,7 +230,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.0.1/developing/getting-started/ruby/querying.md b/content/riak/kv/2.0.1/developing/getting-started/ruby/querying.md index 1726b2ac7e..8da99a6a6d 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/ruby/querying.md @@ -149,7 +149,7 @@ os.data = order_summary os.store ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```ruby shared_key = '1' @@ -190,6 +190,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```ruby @@ -206,7 +212,7 @@ If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL ind end ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```ruby @@ -240,7 +246,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.0.2/developing/getting-started/csharp/querying.md b/content/riak/kv/2.0.2/developing/getting-started/csharp/querying.md index 0317b9471d..f0240271ea 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/csharp/querying.md @@ -124,6 +124,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.2/developing/getting-started/erlang/querying.md b/content/riak/kv/2.0.2/developing/getting-started/erlang/querying.md index d258cdd286..fa8f3281de 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/erlang/querying.md @@ -214,6 +214,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.2/developing/getting-started/golang/querying.md b/content/riak/kv/2.0.2/developing/getting-started/golang/querying.md index d3d875b5dd..578d66639a 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/golang/querying.md @@ -18,7 +18,7 @@ aliases: ## Go Version Setup -For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix OS. +For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix* OS. >A Quick Note on Querying and Schemas: > @@ -340,7 +340,7 @@ func createOrderSummary(customerId string, orders []*Order) *OrderSummary { } ``` -While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. +While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```golang util.Log.Println("Fetching related data by shared key") @@ -415,6 +415,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: ```golang @@ -496,7 +502,7 @@ wg.Wait() close(doneChan) ``` -As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders. We'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`: @@ -564,7 +570,7 @@ Easy! We used 2i's range feature to search for a range of values, and demonstra So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys. * You can search for specific values or a range of values. * Riak will return a list of keys that match the index query. diff --git a/content/riak/kv/2.0.2/developing/getting-started/java/querying.md b/content/riak/kv/2.0.2/developing/getting-started/java/querying.md index d1dc2e59de..7ac1f1b4c6 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/java/querying.md @@ -25,7 +25,7 @@ branch](https://github.com/basho/taste-of-riak/archive/master.zip). The code for this chapter is in `/java/Ch02-Schemas-and-Indexes`. You may import this code into your favorite editor, or just run it from the command line using the commands in `BuildAndRun.sh` if you are running -on a *nix OS. +on a *nix* OS. ## A Quick Note on Querying and Schemas @@ -193,6 +193,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.2/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.0.2/developing/getting-started/nodejs/querying.md index 442f4112d3..76cb4e53bb 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/nodejs/querying.md @@ -86,6 +86,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.2/developing/getting-started/php/querying.md b/content/riak/kv/2.0.2/developing/getting-started/php/querying.md index 9b023bbf1c..ae16a7dd3c 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/php/querying.md @@ -94,7 +94,7 @@ class Item class OrderSummary { - public function __construct() + public function __construct() { $this->summaries = array(); } @@ -104,7 +104,7 @@ class OrderSummary class OrderSummaryItem { - public function __construct(Order $order) + public function __construct(Order $order) { $this->orderId = $order->orderId; $this->total = $order->total; @@ -141,8 +141,8 @@ $order1->items = [ 15.99 ), new Item( - 'PEG10BBF2PP', - 'eTablet Pro; 24GB; Grey', + 'PEG10BBF2PP', + 'eTablet Pro; 24GB; Grey', 399.99 ) ]; @@ -231,7 +231,7 @@ $storeSummary = (new Command\Builder\StoreObject($riak)) $storeSummary->execute(); ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```php // Fetching related data by shared key @@ -297,6 +297,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```php @@ -323,7 +329,7 @@ unset($key); ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```php @@ -354,7 +360,7 @@ Jane processed orders 1 and 3. We used an "integer" index to reference Jane's i Now, let's say that the VP of Sales wants to know how many orders came in during October 2013. In this case, we can exploit 2i's range queries. Let's search the `order_date_bin` index for entries between `20131001` and `20131031`. ```php -// Query for orders where the OrderDate bin index is +// Query for orders where the OrderDate bin index is // between 2013-10-01 and 2013-10-31 $fetchOctoberOrders = (new Command\Builder\QueryIndex($riak)) ->inBucket($ordersBucket) @@ -392,7 +398,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys (and terms if needed) that match the index query diff --git a/content/riak/kv/2.0.2/developing/getting-started/python/querying.md b/content/riak/kv/2.0.2/developing/getting-started/python/querying.md index bafdc0f9bc..221d33645d 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/python/querying.md @@ -150,7 +150,7 @@ os = order_summary_bucket.new(str(order_summary['customer_id']), os.store() ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```python customer = customer_bucket.get('1').data @@ -162,15 +162,15 @@ Which returns our amalgamated objects: ```python { - u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', - u'created_date': u'2013-10-01 14:30:26', - 'order_summary': { + u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', + u'created_date': u'2013-10-01 14:30:26', + 'order_summary': { u'customer_id': 1, u'summaries': [ - {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, - {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, + {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, + {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, {u'order_id': 3, u'order_date': u'2013-11-03 17:45:28', u'total': 74.98} - ]}, - u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', + ]}, + u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', u'customer_id': 1 } ``` @@ -180,6 +180,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```python @@ -191,7 +197,7 @@ for i in range(1, 4): order.store() ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```python @@ -224,7 +230,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.0.2/developing/getting-started/ruby/querying.md b/content/riak/kv/2.0.2/developing/getting-started/ruby/querying.md index e5346a81c5..68c0869828 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/ruby/querying.md @@ -149,7 +149,7 @@ os.data = order_summary os.store ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```ruby shared_key = '1' @@ -190,6 +190,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```ruby @@ -206,7 +212,7 @@ If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL ind end ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```ruby @@ -240,7 +246,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.0.4/developing/getting-started/csharp/querying.md b/content/riak/kv/2.0.4/developing/getting-started/csharp/querying.md index e9dbe53fbf..d23906b38c 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/csharp/querying.md @@ -124,6 +124,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.4/developing/getting-started/erlang/querying.md b/content/riak/kv/2.0.4/developing/getting-started/erlang/querying.md index 1eb4d5e43b..231db10deb 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/erlang/querying.md @@ -214,6 +214,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.4/developing/getting-started/golang/querying.md b/content/riak/kv/2.0.4/developing/getting-started/golang/querying.md index e0531ab242..a59ad56d25 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/golang/querying.md @@ -18,7 +18,7 @@ aliases: ## Go Version Setup -For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix OS. +For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix* OS. >A Quick Note on Querying and Schemas: > @@ -340,7 +340,7 @@ func createOrderSummary(customerId string, orders []*Order) *OrderSummary { } ``` -While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. +While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```golang util.Log.Println("Fetching related data by shared key") @@ -415,6 +415,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: ```golang @@ -496,7 +502,7 @@ wg.Wait() close(doneChan) ``` -As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders. We'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`: @@ -564,7 +570,7 @@ Easy! We used 2i's range feature to search for a range of values, and demonstra So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys. * You can search for specific values or a range of values. * Riak will return a list of keys that match the index query. diff --git a/content/riak/kv/2.0.4/developing/getting-started/java/querying.md b/content/riak/kv/2.0.4/developing/getting-started/java/querying.md index dc5f975ee0..4fc143876f 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/java/querying.md @@ -25,7 +25,7 @@ branch](https://github.com/basho/taste-of-riak/archive/master.zip). The code for this chapter is in `/java/Ch02-Schemas-and-Indexes`. You may import this code into your favorite editor, or just run it from the command line using the commands in `BuildAndRun.sh` if you are running -on a *nix OS. +on a *nix* OS. ## A Quick Note on Querying and Schemas @@ -193,6 +193,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.4/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.0.4/developing/getting-started/nodejs/querying.md index 175221bc06..173fe8da3a 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/nodejs/querying.md @@ -86,6 +86,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.4/developing/getting-started/php/querying.md b/content/riak/kv/2.0.4/developing/getting-started/php/querying.md index 1196a3cac9..d3d9252a77 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/php/querying.md @@ -94,7 +94,7 @@ class Item class OrderSummary { - public function __construct() + public function __construct() { $this->summaries = array(); } @@ -104,7 +104,7 @@ class OrderSummary class OrderSummaryItem { - public function __construct(Order $order) + public function __construct(Order $order) { $this->orderId = $order->orderId; $this->total = $order->total; @@ -141,8 +141,8 @@ $order1->items = [ 15.99 ), new Item( - 'PEG10BBF2PP', - 'eTablet Pro; 24GB; Grey', + 'PEG10BBF2PP', + 'eTablet Pro; 24GB; Grey', 399.99 ) ]; @@ -231,7 +231,7 @@ $storeSummary = (new Command\Builder\StoreObject($riak)) $storeSummary->execute(); ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```php // Fetching related data by shared key @@ -297,6 +297,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```php @@ -323,7 +329,7 @@ unset($key); ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```php @@ -354,7 +360,7 @@ Jane processed orders 1 and 3. We used an "integer" index to reference Jane's i Now, let's say that the VP of Sales wants to know how many orders came in during October 2013. In this case, we can exploit 2i's range queries. Let's search the `order_date_bin` index for entries between `20131001` and `20131031`. ```php -// Query for orders where the OrderDate bin index is +// Query for orders where the OrderDate bin index is // between 2013-10-01 and 2013-10-31 $fetchOctoberOrders = (new Command\Builder\QueryIndex($riak)) ->inBucket($ordersBucket) @@ -392,7 +398,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys (and terms if needed) that match the index query diff --git a/content/riak/kv/2.0.4/developing/getting-started/python/querying.md b/content/riak/kv/2.0.4/developing/getting-started/python/querying.md index ead86999e3..68b274192d 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/python/querying.md @@ -150,7 +150,7 @@ os = order_summary_bucket.new(str(order_summary['customer_id']), os.store() ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```python customer = customer_bucket.get('1').data @@ -162,15 +162,15 @@ Which returns our amalgamated objects: ```python { - u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', - u'created_date': u'2013-10-01 14:30:26', - 'order_summary': { + u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', + u'created_date': u'2013-10-01 14:30:26', + 'order_summary': { u'customer_id': 1, u'summaries': [ - {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, - {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, + {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, + {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, {u'order_id': 3, u'order_date': u'2013-11-03 17:45:28', u'total': 74.98} - ]}, - u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', + ]}, + u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', u'customer_id': 1 } ``` @@ -180,6 +180,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```python @@ -191,7 +197,7 @@ for i in range(1, 4): order.store() ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```python @@ -224,7 +230,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.0.4/developing/getting-started/ruby/querying.md b/content/riak/kv/2.0.4/developing/getting-started/ruby/querying.md index f4154f272d..17b3658cc4 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/ruby/querying.md @@ -149,7 +149,7 @@ os.data = order_summary os.store ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```ruby shared_key = '1' @@ -190,6 +190,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```ruby @@ -206,7 +212,7 @@ If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL ind end ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```ruby @@ -240,7 +246,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.0.5/developing/getting-started/csharp/querying.md b/content/riak/kv/2.0.5/developing/getting-started/csharp/querying.md index a466c9b55a..060f346121 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/csharp/querying.md @@ -124,6 +124,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.5/developing/getting-started/erlang/querying.md b/content/riak/kv/2.0.5/developing/getting-started/erlang/querying.md index a263e88830..752522199a 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/erlang/querying.md @@ -214,6 +214,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.5/developing/getting-started/golang/querying.md b/content/riak/kv/2.0.5/developing/getting-started/golang/querying.md index 6c1b1ad8bc..92613c168a 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/golang/querying.md @@ -18,7 +18,7 @@ aliases: ## Go Version Setup -For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix OS. +For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix* OS. >A Quick Note on Querying and Schemas: > @@ -340,7 +340,7 @@ func createOrderSummary(customerId string, orders []*Order) *OrderSummary { } ``` -While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. +While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```golang util.Log.Println("Fetching related data by shared key") @@ -415,6 +415,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: ```golang @@ -496,7 +502,7 @@ wg.Wait() close(doneChan) ``` -As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders. We'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`: @@ -564,7 +570,7 @@ Easy! We used 2i's range feature to search for a range of values, and demonstra So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys. * You can search for specific values or a range of values. * Riak will return a list of keys that match the index query. diff --git a/content/riak/kv/2.0.5/developing/getting-started/java/querying.md b/content/riak/kv/2.0.5/developing/getting-started/java/querying.md index 36f975988b..de82b0d3f9 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/java/querying.md @@ -25,7 +25,7 @@ branch](https://github.com/basho/taste-of-riak/archive/master.zip). The code for this chapter is in `/java/Ch02-Schemas-and-Indexes`. You may import this code into your favorite editor, or just run it from the command line using the commands in `BuildAndRun.sh` if you are running -on a *nix OS. +on a *nix* OS. ## A Quick Note on Querying and Schemas @@ -193,6 +193,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.5/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.0.5/developing/getting-started/nodejs/querying.md index a0062c41b2..6acf7d2d43 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/nodejs/querying.md @@ -86,6 +86,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.5/developing/getting-started/php/querying.md b/content/riak/kv/2.0.5/developing/getting-started/php/querying.md index f1936b6139..fbe65d5071 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/php/querying.md @@ -94,7 +94,7 @@ class Item class OrderSummary { - public function __construct() + public function __construct() { $this->summaries = array(); } @@ -104,7 +104,7 @@ class OrderSummary class OrderSummaryItem { - public function __construct(Order $order) + public function __construct(Order $order) { $this->orderId = $order->orderId; $this->total = $order->total; @@ -141,8 +141,8 @@ $order1->items = [ 15.99 ), new Item( - 'PEG10BBF2PP', - 'eTablet Pro; 24GB; Grey', + 'PEG10BBF2PP', + 'eTablet Pro; 24GB; Grey', 399.99 ) ]; @@ -231,7 +231,7 @@ $storeSummary = (new Command\Builder\StoreObject($riak)) $storeSummary->execute(); ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```php // Fetching related data by shared key @@ -297,6 +297,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```php @@ -323,7 +329,7 @@ unset($key); ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```php @@ -354,7 +360,7 @@ Jane processed orders 1 and 3. We used an "integer" index to reference Jane's i Now, let's say that the VP of Sales wants to know how many orders came in during October 2013. In this case, we can exploit 2i's range queries. Let's search the `order_date_bin` index for entries between `20131001` and `20131031`. ```php -// Query for orders where the OrderDate bin index is +// Query for orders where the OrderDate bin index is // between 2013-10-01 and 2013-10-31 $fetchOctoberOrders = (new Command\Builder\QueryIndex($riak)) ->inBucket($ordersBucket) @@ -392,7 +398,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys (and terms if needed) that match the index query diff --git a/content/riak/kv/2.0.5/developing/getting-started/python/querying.md b/content/riak/kv/2.0.5/developing/getting-started/python/querying.md index be573bd052..756857bbf0 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/python/querying.md @@ -150,7 +150,7 @@ os = order_summary_bucket.new(str(order_summary['customer_id']), os.store() ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```python customer = customer_bucket.get('1').data @@ -162,15 +162,15 @@ Which returns our amalgamated objects: ```python { - u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', - u'created_date': u'2013-10-01 14:30:26', - 'order_summary': { + u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', + u'created_date': u'2013-10-01 14:30:26', + 'order_summary': { u'customer_id': 1, u'summaries': [ - {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, - {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, + {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, + {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, {u'order_id': 3, u'order_date': u'2013-11-03 17:45:28', u'total': 74.98} - ]}, - u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', + ]}, + u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', u'customer_id': 1 } ``` @@ -180,6 +180,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```python @@ -191,7 +197,7 @@ for i in range(1, 4): order.store() ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```python @@ -224,7 +230,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.0.5/developing/getting-started/ruby/querying.md b/content/riak/kv/2.0.5/developing/getting-started/ruby/querying.md index 155d1596f7..fbadb82681 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/ruby/querying.md @@ -149,7 +149,7 @@ os.data = order_summary os.store ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```ruby shared_key = '1' @@ -190,6 +190,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```ruby @@ -206,7 +212,7 @@ If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL ind end ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```ruby @@ -240,7 +246,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.0.6/developing/getting-started/csharp/querying.md b/content/riak/kv/2.0.6/developing/getting-started/csharp/querying.md index d3b87f5907..ade351a613 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/csharp/querying.md @@ -124,6 +124,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.6/developing/getting-started/erlang/querying.md b/content/riak/kv/2.0.6/developing/getting-started/erlang/querying.md index 1f093d813a..4dd62cd66d 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/erlang/querying.md @@ -214,6 +214,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.6/developing/getting-started/golang/querying.md b/content/riak/kv/2.0.6/developing/getting-started/golang/querying.md index b23d611cb1..aa54832018 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/golang/querying.md @@ -18,7 +18,7 @@ aliases: ## Go Version Setup -For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix OS. +For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix* OS. >A Quick Note on Querying and Schemas: > @@ -340,7 +340,7 @@ func createOrderSummary(customerId string, orders []*Order) *OrderSummary { } ``` -While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. +While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```golang util.Log.Println("Fetching related data by shared key") @@ -415,6 +415,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: ```golang @@ -496,7 +502,7 @@ wg.Wait() close(doneChan) ``` -As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders. We'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`: @@ -564,7 +570,7 @@ Easy! We used 2i's range feature to search for a range of values, and demonstra So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys. * You can search for specific values or a range of values. * Riak will return a list of keys that match the index query. diff --git a/content/riak/kv/2.0.6/developing/getting-started/java/querying.md b/content/riak/kv/2.0.6/developing/getting-started/java/querying.md index ea7594a8b2..c0538fb9ed 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/java/querying.md @@ -25,7 +25,7 @@ branch](https://github.com/basho/taste-of-riak/archive/master.zip). The code for this chapter is in `/java/Ch02-Schemas-and-Indexes`. You may import this code into your favorite editor, or just run it from the command line using the commands in `BuildAndRun.sh` if you are running -on a *nix OS. +on a *nix* OS. ## A Quick Note on Querying and Schemas @@ -193,6 +193,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.6/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.0.6/developing/getting-started/nodejs/querying.md index 9f4154b781..cc205d1f37 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/nodejs/querying.md @@ -86,6 +86,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.6/developing/getting-started/php/querying.md b/content/riak/kv/2.0.6/developing/getting-started/php/querying.md index 11417eeab8..87e03b4700 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/php/querying.md @@ -94,7 +94,7 @@ class Item class OrderSummary { - public function __construct() + public function __construct() { $this->summaries = array(); } @@ -104,7 +104,7 @@ class OrderSummary class OrderSummaryItem { - public function __construct(Order $order) + public function __construct(Order $order) { $this->orderId = $order->orderId; $this->total = $order->total; @@ -141,8 +141,8 @@ $order1->items = [ 15.99 ), new Item( - 'PEG10BBF2PP', - 'eTablet Pro; 24GB; Grey', + 'PEG10BBF2PP', + 'eTablet Pro; 24GB; Grey', 399.99 ) ]; @@ -231,7 +231,7 @@ $storeSummary = (new Command\Builder\StoreObject($riak)) $storeSummary->execute(); ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```php // Fetching related data by shared key @@ -297,6 +297,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```php @@ -323,7 +329,7 @@ unset($key); ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```php @@ -354,7 +360,7 @@ Jane processed orders 1 and 3. We used an "integer" index to reference Jane's i Now, let's say that the VP of Sales wants to know how many orders came in during October 2013. In this case, we can exploit 2i's range queries. Let's search the `order_date_bin` index for entries between `20131001` and `20131031`. ```php -// Query for orders where the OrderDate bin index is +// Query for orders where the OrderDate bin index is // between 2013-10-01 and 2013-10-31 $fetchOctoberOrders = (new Command\Builder\QueryIndex($riak)) ->inBucket($ordersBucket) @@ -392,7 +398,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys (and terms if needed) that match the index query diff --git a/content/riak/kv/2.0.6/developing/getting-started/python/querying.md b/content/riak/kv/2.0.6/developing/getting-started/python/querying.md index 312d1ac838..228e2ceb06 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/python/querying.md @@ -150,7 +150,7 @@ os = order_summary_bucket.new(str(order_summary['customer_id']), os.store() ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```python customer = customer_bucket.get('1').data @@ -162,15 +162,15 @@ Which returns our amalgamated objects: ```python { - u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', - u'created_date': u'2013-10-01 14:30:26', - 'order_summary': { + u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', + u'created_date': u'2013-10-01 14:30:26', + 'order_summary': { u'customer_id': 1, u'summaries': [ - {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, - {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, + {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, + {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, {u'order_id': 3, u'order_date': u'2013-11-03 17:45:28', u'total': 74.98} - ]}, - u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', + ]}, + u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', u'customer_id': 1 } ``` @@ -180,6 +180,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```python @@ -191,7 +197,7 @@ for i in range(1, 4): order.store() ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```python @@ -224,7 +230,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.0.6/developing/getting-started/ruby/querying.md b/content/riak/kv/2.0.6/developing/getting-started/ruby/querying.md index 8c810ba2be..6eb03aa97b 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/ruby/querying.md @@ -149,7 +149,7 @@ os.data = order_summary os.store ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```ruby shared_key = '1' @@ -190,6 +190,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```ruby @@ -206,7 +212,7 @@ If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL ind end ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```ruby @@ -240,7 +246,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.0.7/developing/getting-started/csharp/querying.md b/content/riak/kv/2.0.7/developing/getting-started/csharp/querying.md index 7c90ed2b51..c994d9b943 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/csharp/querying.md @@ -124,6 +124,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.7/developing/getting-started/erlang/querying.md b/content/riak/kv/2.0.7/developing/getting-started/erlang/querying.md index cb6ef54b10..5f78769863 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/erlang/querying.md @@ -214,6 +214,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.7/developing/getting-started/golang/querying.md b/content/riak/kv/2.0.7/developing/getting-started/golang/querying.md index 2524c45907..c1c2080c30 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/golang/querying.md @@ -18,7 +18,7 @@ aliases: ## Go Version Setup -For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix OS. +For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix* OS. >A Quick Note on Querying and Schemas: > @@ -340,7 +340,7 @@ func createOrderSummary(customerId string, orders []*Order) *OrderSummary { } ``` -While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. +While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```golang util.Log.Println("Fetching related data by shared key") @@ -415,6 +415,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: ```golang @@ -496,7 +502,7 @@ wg.Wait() close(doneChan) ``` -As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders. We'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`: @@ -564,7 +570,7 @@ Easy! We used 2i's range feature to search for a range of values, and demonstra So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys. * You can search for specific values or a range of values. * Riak will return a list of keys that match the index query. diff --git a/content/riak/kv/2.0.7/developing/getting-started/java/querying.md b/content/riak/kv/2.0.7/developing/getting-started/java/querying.md index fda0e405ef..3665cb4fe9 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/java/querying.md @@ -25,7 +25,7 @@ branch](https://github.com/basho/taste-of-riak/archive/master.zip). The code for this chapter is in `/java/Ch02-Schemas-and-Indexes`. You may import this code into your favorite editor, or just run it from the command line using the commands in `BuildAndRun.sh` if you are running -on a *nix OS. +on a *nix* OS. ## A Quick Note on Querying and Schemas @@ -193,6 +193,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.7/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.0.7/developing/getting-started/nodejs/querying.md index 66cf39c229..fee559b5a4 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/nodejs/querying.md @@ -86,6 +86,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.0.7/developing/getting-started/php/querying.md b/content/riak/kv/2.0.7/developing/getting-started/php/querying.md index 06460645f7..3d742c16dd 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/php/querying.md @@ -94,7 +94,7 @@ class Item class OrderSummary { - public function __construct() + public function __construct() { $this->summaries = array(); } @@ -104,7 +104,7 @@ class OrderSummary class OrderSummaryItem { - public function __construct(Order $order) + public function __construct(Order $order) { $this->orderId = $order->orderId; $this->total = $order->total; @@ -141,8 +141,8 @@ $order1->items = [ 15.99 ), new Item( - 'PEG10BBF2PP', - 'eTablet Pro; 24GB; Grey', + 'PEG10BBF2PP', + 'eTablet Pro; 24GB; Grey', 399.99 ) ]; @@ -231,7 +231,7 @@ $storeSummary = (new Command\Builder\StoreObject($riak)) $storeSummary->execute(); ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```php // Fetching related data by shared key @@ -297,6 +297,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```php @@ -323,7 +329,7 @@ unset($key); ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```php @@ -354,7 +360,7 @@ Jane processed orders 1 and 3. We used an "integer" index to reference Jane's i Now, let's say that the VP of Sales wants to know how many orders came in during October 2013. In this case, we can exploit 2i's range queries. Let's search the `order_date_bin` index for entries between `20131001` and `20131031`. ```php -// Query for orders where the OrderDate bin index is +// Query for orders where the OrderDate bin index is // between 2013-10-01 and 2013-10-31 $fetchOctoberOrders = (new Command\Builder\QueryIndex($riak)) ->inBucket($ordersBucket) @@ -392,7 +398,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys (and terms if needed) that match the index query diff --git a/content/riak/kv/2.0.7/developing/getting-started/python/querying.md b/content/riak/kv/2.0.7/developing/getting-started/python/querying.md index 7a32be2db5..13b88d8b1f 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/python/querying.md @@ -150,7 +150,7 @@ os = order_summary_bucket.new(str(order_summary['customer_id']), os.store() ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```python customer = customer_bucket.get('1').data @@ -162,15 +162,15 @@ Which returns our amalgamated objects: ```python { - u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', - u'created_date': u'2013-10-01 14:30:26', - 'order_summary': { + u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', + u'created_date': u'2013-10-01 14:30:26', + 'order_summary': { u'customer_id': 1, u'summaries': [ - {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, - {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, + {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, + {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, {u'order_id': 3, u'order_date': u'2013-11-03 17:45:28', u'total': 74.98} - ]}, - u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', + ]}, + u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', u'customer_id': 1 } ``` @@ -180,6 +180,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```python @@ -191,7 +197,7 @@ for i in range(1, 4): order.store() ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```python @@ -224,7 +230,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.0.7/developing/getting-started/ruby/querying.md b/content/riak/kv/2.0.7/developing/getting-started/ruby/querying.md index 4e496ab298..e7b141f9ec 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/ruby/querying.md @@ -149,7 +149,7 @@ os.data = order_summary os.store ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```ruby shared_key = '1' @@ -190,6 +190,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```ruby @@ -206,7 +212,7 @@ If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL ind end ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```ruby @@ -240,7 +246,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.1.1/developing/getting-started/csharp/querying.md b/content/riak/kv/2.1.1/developing/getting-started/csharp/querying.md index d457083178..732ec554c7 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/csharp/querying.md @@ -124,6 +124,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.1.1/developing/getting-started/erlang/querying.md b/content/riak/kv/2.1.1/developing/getting-started/erlang/querying.md index 7cc6e11d3c..4c6a4a29ef 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/erlang/querying.md @@ -214,6 +214,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.1.1/developing/getting-started/golang/querying.md b/content/riak/kv/2.1.1/developing/getting-started/golang/querying.md index e07a45735b..419ff3ec02 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/golang/querying.md @@ -18,7 +18,7 @@ aliases: ## Go Version Setup -For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix OS. +For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix* OS. >A Quick Note on Querying and Schemas: > @@ -340,7 +340,7 @@ func createOrderSummary(customerId string, orders []*Order) *OrderSummary { } ``` -While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. +While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```golang util.Log.Println("Fetching related data by shared key") @@ -415,6 +415,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: ```golang @@ -496,7 +502,7 @@ wg.Wait() close(doneChan) ``` -As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders. We'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`: @@ -564,7 +570,7 @@ Easy! We used 2i's range feature to search for a range of values, and demonstra So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys. * You can search for specific values or a range of values. * Riak will return a list of keys that match the index query. diff --git a/content/riak/kv/2.1.1/developing/getting-started/java/querying.md b/content/riak/kv/2.1.1/developing/getting-started/java/querying.md index 03a5e65977..69ab4ac633 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/java/querying.md @@ -25,7 +25,7 @@ branch](https://github.com/basho/taste-of-riak/archive/master.zip). The code for this chapter is in `/java/Ch02-Schemas-and-Indexes`. You may import this code into your favorite editor, or just run it from the command line using the commands in `BuildAndRun.sh` if you are running -on a *nix OS. +on a *nix* OS. ## A Quick Note on Querying and Schemas @@ -193,6 +193,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.1.1/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.1.1/developing/getting-started/nodejs/querying.md index bbf0614949..e6e143d829 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/nodejs/querying.md @@ -86,6 +86,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.1.1/developing/getting-started/php/querying.md b/content/riak/kv/2.1.1/developing/getting-started/php/querying.md index d916369ae0..58a986c24d 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/php/querying.md @@ -94,7 +94,7 @@ class Item class OrderSummary { - public function __construct() + public function __construct() { $this->summaries = array(); } @@ -104,7 +104,7 @@ class OrderSummary class OrderSummaryItem { - public function __construct(Order $order) + public function __construct(Order $order) { $this->orderId = $order->orderId; $this->total = $order->total; @@ -141,8 +141,8 @@ $order1->items = [ 15.99 ), new Item( - 'PEG10BBF2PP', - 'eTablet Pro; 24GB; Grey', + 'PEG10BBF2PP', + 'eTablet Pro; 24GB; Grey', 399.99 ) ]; @@ -231,7 +231,7 @@ $storeSummary = (new Command\Builder\StoreObject($riak)) $storeSummary->execute(); ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```php // Fetching related data by shared key @@ -297,6 +297,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```php @@ -323,7 +329,7 @@ unset($key); ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```php @@ -354,7 +360,7 @@ Jane processed orders 1 and 3. We used an "integer" index to reference Jane's i Now, let's say that the VP of Sales wants to know how many orders came in during October 2013. In this case, we can exploit 2i's range queries. Let's search the `order_date_bin` index for entries between `20131001` and `20131031`. ```php -// Query for orders where the OrderDate bin index is +// Query for orders where the OrderDate bin index is // between 2013-10-01 and 2013-10-31 $fetchOctoberOrders = (new Command\Builder\QueryIndex($riak)) ->inBucket($ordersBucket) @@ -392,7 +398,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys (and terms if needed) that match the index query diff --git a/content/riak/kv/2.1.1/developing/getting-started/python/querying.md b/content/riak/kv/2.1.1/developing/getting-started/python/querying.md index ac53dcad2e..9bbda8f352 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/python/querying.md @@ -150,7 +150,7 @@ os = order_summary_bucket.new(str(order_summary['customer_id']), os.store() ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```python customer = customer_bucket.get('1').data @@ -162,15 +162,15 @@ Which returns our amalgamated objects: ```python { - u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', - u'created_date': u'2013-10-01 14:30:26', - 'order_summary': { + u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', + u'created_date': u'2013-10-01 14:30:26', + 'order_summary': { u'customer_id': 1, u'summaries': [ - {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, - {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, + {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, + {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, {u'order_id': 3, u'order_date': u'2013-11-03 17:45:28', u'total': 74.98} - ]}, - u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', + ]}, + u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', u'customer_id': 1 } ``` @@ -180,6 +180,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```python @@ -191,7 +197,7 @@ for i in range(1, 4): order.store() ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```python @@ -224,7 +230,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.1.1/developing/getting-started/ruby/querying.md b/content/riak/kv/2.1.1/developing/getting-started/ruby/querying.md index 943a8475f2..de65af7522 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/ruby/querying.md @@ -149,7 +149,7 @@ os.data = order_summary os.store ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```ruby shared_key = '1' @@ -190,6 +190,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```ruby @@ -206,7 +212,7 @@ If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL ind end ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```ruby @@ -240,7 +246,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.1.3/developing/getting-started/csharp/querying.md b/content/riak/kv/2.1.3/developing/getting-started/csharp/querying.md index 3ec3105a5b..2c027c43a6 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/csharp/querying.md @@ -124,6 +124,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.1.3/developing/getting-started/erlang/querying.md b/content/riak/kv/2.1.3/developing/getting-started/erlang/querying.md index 476e0fb600..8a23c86aac 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/erlang/querying.md @@ -214,6 +214,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.1.3/developing/getting-started/golang/querying.md b/content/riak/kv/2.1.3/developing/getting-started/golang/querying.md index 116e0aa149..18374bba84 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/golang/querying.md @@ -18,7 +18,7 @@ aliases: ## Go Version Setup -For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix OS. +For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix* OS. >A Quick Note on Querying and Schemas: > @@ -340,7 +340,7 @@ func createOrderSummary(customerId string, orders []*Order) *OrderSummary { } ``` -While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. +While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```golang util.Log.Println("Fetching related data by shared key") @@ -415,6 +415,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: ```golang @@ -496,7 +502,7 @@ wg.Wait() close(doneChan) ``` -As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders. We'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`: @@ -564,7 +570,7 @@ Easy! We used 2i's range feature to search for a range of values, and demonstra So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys. * You can search for specific values or a range of values. * Riak will return a list of keys that match the index query. diff --git a/content/riak/kv/2.1.3/developing/getting-started/java/querying.md b/content/riak/kv/2.1.3/developing/getting-started/java/querying.md index e2db2c09c1..6a9069ceb5 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/java/querying.md @@ -25,7 +25,7 @@ branch](https://github.com/basho/taste-of-riak/archive/master.zip). The code for this chapter is in `/java/Ch02-Schemas-and-Indexes`. You may import this code into your favorite editor, or just run it from the command line using the commands in `BuildAndRun.sh` if you are running -on a *nix OS. +on a *nix* OS. ## A Quick Note on Querying and Schemas @@ -193,6 +193,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.1.3/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.1.3/developing/getting-started/nodejs/querying.md index 5bcc2ec971..21ddbe3244 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/nodejs/querying.md @@ -86,6 +86,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.1.3/developing/getting-started/php/querying.md b/content/riak/kv/2.1.3/developing/getting-started/php/querying.md index 5eb99e81eb..e7984b4d6b 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/php/querying.md @@ -94,7 +94,7 @@ class Item class OrderSummary { - public function __construct() + public function __construct() { $this->summaries = array(); } @@ -104,7 +104,7 @@ class OrderSummary class OrderSummaryItem { - public function __construct(Order $order) + public function __construct(Order $order) { $this->orderId = $order->orderId; $this->total = $order->total; @@ -141,8 +141,8 @@ $order1->items = [ 15.99 ), new Item( - 'PEG10BBF2PP', - 'eTablet Pro; 24GB; Grey', + 'PEG10BBF2PP', + 'eTablet Pro; 24GB; Grey', 399.99 ) ]; @@ -231,7 +231,7 @@ $storeSummary = (new Command\Builder\StoreObject($riak)) $storeSummary->execute(); ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```php // Fetching related data by shared key @@ -297,6 +297,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```php @@ -323,7 +329,7 @@ unset($key); ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```php @@ -354,7 +360,7 @@ Jane processed orders 1 and 3. We used an "integer" index to reference Jane's i Now, let's say that the VP of Sales wants to know how many orders came in during October 2013. In this case, we can exploit 2i's range queries. Let's search the `order_date_bin` index for entries between `20131001` and `20131031`. ```php -// Query for orders where the OrderDate bin index is +// Query for orders where the OrderDate bin index is // between 2013-10-01 and 2013-10-31 $fetchOctoberOrders = (new Command\Builder\QueryIndex($riak)) ->inBucket($ordersBucket) @@ -392,7 +398,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys (and terms if needed) that match the index query diff --git a/content/riak/kv/2.1.3/developing/getting-started/python/querying.md b/content/riak/kv/2.1.3/developing/getting-started/python/querying.md index 7c94b4db87..46d89f93dc 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/python/querying.md @@ -150,7 +150,7 @@ os = order_summary_bucket.new(str(order_summary['customer_id']), os.store() ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```python customer = customer_bucket.get('1').data @@ -162,15 +162,15 @@ Which returns our amalgamated objects: ```python { - u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', - u'created_date': u'2013-10-01 14:30:26', - 'order_summary': { + u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', + u'created_date': u'2013-10-01 14:30:26', + 'order_summary': { u'customer_id': 1, u'summaries': [ - {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, - {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, + {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, + {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, {u'order_id': 3, u'order_date': u'2013-11-03 17:45:28', u'total': 74.98} - ]}, - u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', + ]}, + u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', u'customer_id': 1 } ``` @@ -180,6 +180,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```python @@ -191,7 +197,7 @@ for i in range(1, 4): order.store() ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```python @@ -224,7 +230,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.1.3/developing/getting-started/ruby/querying.md b/content/riak/kv/2.1.3/developing/getting-started/ruby/querying.md index 578e3dacf3..6230cf2e8f 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/ruby/querying.md @@ -149,7 +149,7 @@ os.data = order_summary os.store ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```ruby shared_key = '1' @@ -190,6 +190,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```ruby @@ -206,7 +212,7 @@ If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL ind end ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```ruby @@ -240,7 +246,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.1.4/developing/getting-started/csharp/querying.md b/content/riak/kv/2.1.4/developing/getting-started/csharp/querying.md index 8d1e3c1326..d93e4d53d8 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/csharp/querying.md @@ -124,6 +124,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.1.4/developing/getting-started/erlang/querying.md b/content/riak/kv/2.1.4/developing/getting-started/erlang/querying.md index 8363bfb94b..17323c4743 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/erlang/querying.md @@ -214,6 +214,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.1.4/developing/getting-started/golang/querying.md b/content/riak/kv/2.1.4/developing/getting-started/golang/querying.md index 991a43526e..10fcb43a6b 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/golang/querying.md @@ -18,7 +18,7 @@ aliases: ## Go Version Setup -For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix OS. +For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix* OS. >A Quick Note on Querying and Schemas: > @@ -340,7 +340,7 @@ func createOrderSummary(customerId string, orders []*Order) *OrderSummary { } ``` -While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. +While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```golang util.Log.Println("Fetching related data by shared key") @@ -415,6 +415,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: ```golang @@ -496,7 +502,7 @@ wg.Wait() close(doneChan) ``` -As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders. We'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`: @@ -564,7 +570,7 @@ Easy! We used 2i's range feature to search for a range of values, and demonstra So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys. * You can search for specific values or a range of values. * Riak will return a list of keys that match the index query. diff --git a/content/riak/kv/2.1.4/developing/getting-started/java/querying.md b/content/riak/kv/2.1.4/developing/getting-started/java/querying.md index d9d0efb5be..a4ca64ff09 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/java/querying.md @@ -25,7 +25,7 @@ branch](https://github.com/basho/taste-of-riak/archive/master.zip). The code for this chapter is in `/java/Ch02-Schemas-and-Indexes`. You may import this code into your favorite editor, or just run it from the command line using the commands in `BuildAndRun.sh` if you are running -on a *nix OS. +on a *nix* OS. ## A Quick Note on Querying and Schemas @@ -193,6 +193,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.1.4/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.1.4/developing/getting-started/nodejs/querying.md index 1b7c4d3d04..3bd4044190 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/nodejs/querying.md @@ -86,6 +86,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.1.4/developing/getting-started/php/querying.md b/content/riak/kv/2.1.4/developing/getting-started/php/querying.md index 97d2e735f4..dd65743094 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/php/querying.md @@ -94,7 +94,7 @@ class Item class OrderSummary { - public function __construct() + public function __construct() { $this->summaries = array(); } @@ -104,7 +104,7 @@ class OrderSummary class OrderSummaryItem { - public function __construct(Order $order) + public function __construct(Order $order) { $this->orderId = $order->orderId; $this->total = $order->total; @@ -141,8 +141,8 @@ $order1->items = [ 15.99 ), new Item( - 'PEG10BBF2PP', - 'eTablet Pro; 24GB; Grey', + 'PEG10BBF2PP', + 'eTablet Pro; 24GB; Grey', 399.99 ) ]; @@ -231,7 +231,7 @@ $storeSummary = (new Command\Builder\StoreObject($riak)) $storeSummary->execute(); ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```php // Fetching related data by shared key @@ -297,6 +297,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```php @@ -323,7 +329,7 @@ unset($key); ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```php @@ -354,7 +360,7 @@ Jane processed orders 1 and 3. We used an "integer" index to reference Jane's i Now, let's say that the VP of Sales wants to know how many orders came in during October 2013. In this case, we can exploit 2i's range queries. Let's search the `order_date_bin` index for entries between `20131001` and `20131031`. ```php -// Query for orders where the OrderDate bin index is +// Query for orders where the OrderDate bin index is // between 2013-10-01 and 2013-10-31 $fetchOctoberOrders = (new Command\Builder\QueryIndex($riak)) ->inBucket($ordersBucket) @@ -392,7 +398,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys (and terms if needed) that match the index query diff --git a/content/riak/kv/2.1.4/developing/getting-started/python/querying.md b/content/riak/kv/2.1.4/developing/getting-started/python/querying.md index b9fea9b57c..c113d2e196 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/python/querying.md @@ -150,7 +150,7 @@ os = order_summary_bucket.new(str(order_summary['customer_id']), os.store() ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```python customer = customer_bucket.get('1').data @@ -162,15 +162,15 @@ Which returns our amalgamated objects: ```python { - u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', - u'created_date': u'2013-10-01 14:30:26', - 'order_summary': { + u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', + u'created_date': u'2013-10-01 14:30:26', + 'order_summary': { u'customer_id': 1, u'summaries': [ - {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, - {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, + {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, + {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, {u'order_id': 3, u'order_date': u'2013-11-03 17:45:28', u'total': 74.98} - ]}, - u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', + ]}, + u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', u'customer_id': 1 } ``` @@ -180,6 +180,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```python @@ -191,7 +197,7 @@ for i in range(1, 4): order.store() ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```python @@ -224,7 +230,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.1.4/developing/getting-started/ruby/querying.md b/content/riak/kv/2.1.4/developing/getting-started/ruby/querying.md index b26ff31df8..778182360a 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/ruby/querying.md @@ -149,7 +149,7 @@ os.data = order_summary os.store ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```ruby shared_key = '1' @@ -190,6 +190,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```ruby @@ -206,7 +212,7 @@ If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL ind end ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```ruby @@ -240,7 +246,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.2.0/developing/getting-started/csharp/querying.md b/content/riak/kv/2.2.0/developing/getting-started/csharp/querying.md index 8df70a09d4..efbd6c8daf 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/csharp/querying.md @@ -124,6 +124,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.2.0/developing/getting-started/erlang/querying.md b/content/riak/kv/2.2.0/developing/getting-started/erlang/querying.md index 314879c752..c218be8f87 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/erlang/querying.md @@ -214,6 +214,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.2.0/developing/getting-started/golang/querying.md b/content/riak/kv/2.2.0/developing/getting-started/golang/querying.md index 7f7c3c0f8b..2bbd7b124a 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/golang/querying.md @@ -18,7 +18,7 @@ aliases: ## Go Version Setup -For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix OS. +For the Go version, please download the source from GitHub by either [cloning](https://github.com/basho/taste-of-riak) the source code repository or downloading the [current zip of the master branch](https://github.com/basho/taste-of-riak/archive/master.zip). Ensure that the source is located in your `GOPATH`. The code for this chapter is in `go/ch02/ch02.go`. You may import this code into your favorite editor, or just run it from the command line using the `Makefile` if you are running on a *nix* OS. >A Quick Note on Querying and Schemas: > @@ -340,7 +340,7 @@ func createOrderSummary(customerId string, orders []*Order) *OrderSummary { } ``` -While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. +While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders and also holding some relevant data, such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```golang util.Log.Println("Fetching related data by shared key") @@ -415,6 +415,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: ```golang @@ -496,7 +502,7 @@ wg.Wait() close(doneChan) ``` -As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary key/value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders. We'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`: @@ -564,7 +570,7 @@ Easy! We used 2i's range feature to search for a range of values, and demonstra So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys. * You can search for specific values or a range of values. * Riak will return a list of keys that match the index query. diff --git a/content/riak/kv/2.2.0/developing/getting-started/java/querying.md b/content/riak/kv/2.2.0/developing/getting-started/java/querying.md index de1184a0ba..b343bbb872 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/java/querying.md @@ -25,7 +25,7 @@ branch](https://github.com/basho/taste-of-riak/archive/master.zip). The code for this chapter is in `/java/Ch02-Schemas-and-Indexes`. You may import this code into your favorite editor, or just run it from the command line using the commands in `BuildAndRun.sh` if you are running -on a *nix OS. +on a *nix* OS. ## A Quick Note on Querying and Schemas @@ -193,6 +193,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.2.0/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.2.0/developing/getting-started/nodejs/querying.md index bb9245b6a2..7d55f75a64 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/nodejs/querying.md @@ -86,6 +86,12 @@ intrinsic relationships. ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from an SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it diff --git a/content/riak/kv/2.2.0/developing/getting-started/php/querying.md b/content/riak/kv/2.2.0/developing/getting-started/php/querying.md index aa6778959b..f0506f9f48 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/php/querying.md @@ -94,7 +94,7 @@ class Item class OrderSummary { - public function __construct() + public function __construct() { $this->summaries = array(); } @@ -104,7 +104,7 @@ class OrderSummary class OrderSummaryItem { - public function __construct(Order $order) + public function __construct(Order $order) { $this->orderId = $order->orderId; $this->total = $order->total; @@ -141,8 +141,8 @@ $order1->items = [ 15.99 ), new Item( - 'PEG10BBF2PP', - 'eTablet Pro; 24GB; Grey', + 'PEG10BBF2PP', + 'eTablet Pro; 24GB; Grey', 399.99 ) ]; @@ -231,7 +231,7 @@ $storeSummary = (new Command\Builder\StoreObject($riak)) $storeSummary->execute(); ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```php // Fetching related data by shared key @@ -297,6 +297,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```php @@ -323,7 +329,7 @@ unset($key); ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```php @@ -354,7 +360,7 @@ Jane processed orders 1 and 3. We used an "integer" index to reference Jane's i Now, let's say that the VP of Sales wants to know how many orders came in during October 2013. In this case, we can exploit 2i's range queries. Let's search the `order_date_bin` index for entries between `20131001` and `20131031`. ```php -// Query for orders where the OrderDate bin index is +// Query for orders where the OrderDate bin index is // between 2013-10-01 and 2013-10-31 $fetchOctoberOrders = (new Command\Builder\QueryIndex($riak)) ->inBucket($ordersBucket) @@ -392,7 +398,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys (and terms if needed) that match the index query diff --git a/content/riak/kv/2.2.0/developing/getting-started/python/querying.md b/content/riak/kv/2.2.0/developing/getting-started/python/querying.md index 7c2b79f692..22a39a56fc 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/python/querying.md @@ -150,7 +150,7 @@ os = order_summary_bucket.new(str(order_summary['customer_id']), os.store() ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all customer orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```python customer = customer_bucket.get('1').data @@ -162,15 +162,15 @@ Which returns our amalgamated objects: ```python { - u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', - u'created_date': u'2013-10-01 14:30:26', - 'order_summary': { + u'city': u'Columbus', u'name': u'John Smith', u'zip': u'43210', + u'created_date': u'2013-10-01 14:30:26', + 'order_summary': { u'customer_id': 1, u'summaries': [ - {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, - {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, + {u'order_id': 1, u'order_date': u'2013-10-01 14:42:26', u'total': 415.98}, + {u'order_id': 2, u'order_date': u'2013-10-15 16:43:16', u'total': 359.99}, {u'order_id': 3, u'order_date': u'2013-11-03 17:45:28', u'total': 74.98} - ]}, - u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', + ]}, + u'phone': u'+1-614-555-5555', u'state': u'Ohio', u'address': u'123 Main Street', u'customer_id': 1 } ``` @@ -180,6 +180,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```python @@ -191,7 +197,7 @@ for i in range(1, 4): order.store() ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```python @@ -224,7 +230,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query diff --git a/content/riak/kv/2.2.0/developing/getting-started/ruby/querying.md b/content/riak/kv/2.2.0/developing/getting-started/ruby/querying.md index fe72e4ffd5..d0daaa346a 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/ruby/querying.md @@ -149,7 +149,7 @@ os.data = order_summary os.store ``` - While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. + While individual `Customer` and `Order` objects don't change much (or shouldn't change), the `Order Summaries` object will likely change often. It will do double duty by acting as an index for all a customer's orders, and also holding some relevant data such as the order total, etc. If we showed this information in our application often, it's only one extra request to get all the info. ```ruby shared_key = '1' @@ -190,6 +190,12 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes +{{% note %}} +Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. + +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +{{% /note %}} + If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. ```ruby @@ -206,7 +212,7 @@ If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL ind end ``` -As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. +As you may have noticed, ordinary Key/Value data is opaque to 2i, so we have to add entries to the indexes at the application level. Now let's find all of Jane Appleseed's processed orders, we'll lookup the orders by searching the `saleperson_id_int` index for Jane's id of `9000`. ```ruby @@ -240,7 +246,7 @@ Boom, easy-peasy. We used 2i's range feature to search for a range of values, a So to recap: -* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. +* You can use Secondary Indexes to quickly lookup an object based on a secondary id other than the object's key. * Indexes can have either Integer or Binary(String) keys * You can search for specific values, or a range of values * Riak will return a list of keys that match the index query From d1e1f4f272b81c20bcd32b725f87ab99d4234bb1 Mon Sep 17 00:00:00 2001 From: Eric Date: Tue, 17 Jan 2017 09:27:02 -0800 Subject: [PATCH 2/2] Lowercase secondary indexes --- .../kv/2.0.0/developing/getting-started/csharp/querying.md | 4 ++-- .../kv/2.0.0/developing/getting-started/erlang/querying.md | 4 ++-- .../kv/2.0.0/developing/getting-started/golang/querying.md | 4 ++-- .../riak/kv/2.0.0/developing/getting-started/java/querying.md | 4 ++-- .../kv/2.0.0/developing/getting-started/nodejs/querying.md | 4 ++-- .../riak/kv/2.0.0/developing/getting-started/php/querying.md | 4 ++-- .../kv/2.0.0/developing/getting-started/python/querying.md | 4 ++-- .../riak/kv/2.0.0/developing/getting-started/ruby/querying.md | 4 ++-- .../kv/2.0.1/developing/getting-started/csharp/querying.md | 4 ++-- .../kv/2.0.1/developing/getting-started/erlang/querying.md | 4 ++-- .../kv/2.0.1/developing/getting-started/golang/querying.md | 4 ++-- .../riak/kv/2.0.1/developing/getting-started/java/querying.md | 4 ++-- .../kv/2.0.1/developing/getting-started/nodejs/querying.md | 4 ++-- .../riak/kv/2.0.1/developing/getting-started/php/querying.md | 4 ++-- .../kv/2.0.1/developing/getting-started/python/querying.md | 4 ++-- .../riak/kv/2.0.1/developing/getting-started/ruby/querying.md | 4 ++-- .../kv/2.0.2/developing/getting-started/csharp/querying.md | 4 ++-- .../kv/2.0.2/developing/getting-started/erlang/querying.md | 4 ++-- .../kv/2.0.2/developing/getting-started/golang/querying.md | 4 ++-- .../riak/kv/2.0.2/developing/getting-started/java/querying.md | 4 ++-- .../kv/2.0.2/developing/getting-started/nodejs/querying.md | 4 ++-- .../riak/kv/2.0.2/developing/getting-started/php/querying.md | 4 ++-- .../kv/2.0.2/developing/getting-started/python/querying.md | 4 ++-- .../riak/kv/2.0.2/developing/getting-started/ruby/querying.md | 4 ++-- .../kv/2.0.4/developing/getting-started/csharp/querying.md | 4 ++-- .../kv/2.0.4/developing/getting-started/erlang/querying.md | 4 ++-- .../kv/2.0.4/developing/getting-started/golang/querying.md | 4 ++-- .../riak/kv/2.0.4/developing/getting-started/java/querying.md | 4 ++-- .../kv/2.0.4/developing/getting-started/nodejs/querying.md | 4 ++-- .../riak/kv/2.0.4/developing/getting-started/php/querying.md | 4 ++-- .../kv/2.0.4/developing/getting-started/python/querying.md | 4 ++-- .../riak/kv/2.0.4/developing/getting-started/ruby/querying.md | 4 ++-- .../kv/2.0.5/developing/getting-started/csharp/querying.md | 4 ++-- .../kv/2.0.5/developing/getting-started/erlang/querying.md | 4 ++-- .../kv/2.0.5/developing/getting-started/golang/querying.md | 4 ++-- .../riak/kv/2.0.5/developing/getting-started/java/querying.md | 4 ++-- .../kv/2.0.5/developing/getting-started/nodejs/querying.md | 4 ++-- .../riak/kv/2.0.5/developing/getting-started/php/querying.md | 4 ++-- .../kv/2.0.5/developing/getting-started/python/querying.md | 4 ++-- .../riak/kv/2.0.5/developing/getting-started/ruby/querying.md | 4 ++-- .../kv/2.0.6/developing/getting-started/csharp/querying.md | 4 ++-- .../kv/2.0.6/developing/getting-started/erlang/querying.md | 4 ++-- .../kv/2.0.6/developing/getting-started/golang/querying.md | 4 ++-- .../riak/kv/2.0.6/developing/getting-started/java/querying.md | 4 ++-- .../kv/2.0.6/developing/getting-started/nodejs/querying.md | 4 ++-- .../riak/kv/2.0.6/developing/getting-started/php/querying.md | 4 ++-- .../kv/2.0.6/developing/getting-started/python/querying.md | 4 ++-- .../riak/kv/2.0.6/developing/getting-started/ruby/querying.md | 4 ++-- .../kv/2.0.7/developing/getting-started/csharp/querying.md | 4 ++-- .../kv/2.0.7/developing/getting-started/erlang/querying.md | 4 ++-- .../kv/2.0.7/developing/getting-started/golang/querying.md | 4 ++-- .../riak/kv/2.0.7/developing/getting-started/java/querying.md | 4 ++-- .../kv/2.0.7/developing/getting-started/nodejs/querying.md | 4 ++-- .../riak/kv/2.0.7/developing/getting-started/php/querying.md | 4 ++-- .../kv/2.0.7/developing/getting-started/python/querying.md | 4 ++-- .../riak/kv/2.0.7/developing/getting-started/ruby/querying.md | 4 ++-- .../kv/2.1.1/developing/getting-started/csharp/querying.md | 4 ++-- .../kv/2.1.1/developing/getting-started/erlang/querying.md | 4 ++-- .../kv/2.1.1/developing/getting-started/golang/querying.md | 4 ++-- .../riak/kv/2.1.1/developing/getting-started/java/querying.md | 4 ++-- .../kv/2.1.1/developing/getting-started/nodejs/querying.md | 4 ++-- .../riak/kv/2.1.1/developing/getting-started/php/querying.md | 4 ++-- .../kv/2.1.1/developing/getting-started/python/querying.md | 4 ++-- .../riak/kv/2.1.1/developing/getting-started/ruby/querying.md | 4 ++-- .../kv/2.1.3/developing/getting-started/csharp/querying.md | 4 ++-- .../kv/2.1.3/developing/getting-started/erlang/querying.md | 4 ++-- .../kv/2.1.3/developing/getting-started/golang/querying.md | 4 ++-- .../riak/kv/2.1.3/developing/getting-started/java/querying.md | 4 ++-- .../kv/2.1.3/developing/getting-started/nodejs/querying.md | 4 ++-- .../riak/kv/2.1.3/developing/getting-started/php/querying.md | 4 ++-- .../kv/2.1.3/developing/getting-started/python/querying.md | 4 ++-- .../riak/kv/2.1.3/developing/getting-started/ruby/querying.md | 4 ++-- .../kv/2.1.4/developing/getting-started/csharp/querying.md | 4 ++-- .../kv/2.1.4/developing/getting-started/erlang/querying.md | 4 ++-- .../kv/2.1.4/developing/getting-started/golang/querying.md | 4 ++-- .../riak/kv/2.1.4/developing/getting-started/java/querying.md | 4 ++-- .../kv/2.1.4/developing/getting-started/nodejs/querying.md | 4 ++-- .../riak/kv/2.1.4/developing/getting-started/php/querying.md | 4 ++-- .../kv/2.1.4/developing/getting-started/python/querying.md | 4 ++-- .../riak/kv/2.1.4/developing/getting-started/ruby/querying.md | 4 ++-- .../kv/2.2.0/developing/getting-started/csharp/querying.md | 4 ++-- .../kv/2.2.0/developing/getting-started/erlang/querying.md | 4 ++-- .../kv/2.2.0/developing/getting-started/golang/querying.md | 4 ++-- .../riak/kv/2.2.0/developing/getting-started/java/querying.md | 4 ++-- .../kv/2.2.0/developing/getting-started/nodejs/querying.md | 4 ++-- .../riak/kv/2.2.0/developing/getting-started/php/querying.md | 4 ++-- .../kv/2.2.0/developing/getting-started/python/querying.md | 4 ++-- .../riak/kv/2.2.0/developing/getting-started/ruby/querying.md | 4 ++-- 88 files changed, 176 insertions(+), 176 deletions(-) diff --git a/content/riak/kv/2.0.0/developing/getting-started/csharp/querying.md b/content/riak/kv/2.0.0/developing/getting-started/csharp/querying.md index ed3327b8ff..b3a559cf22 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/csharp/querying.md @@ -125,9 +125,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.0/developing/getting-started/erlang/querying.md b/content/riak/kv/2.0.0/developing/getting-started/erlang/querying.md index 6c9b31fb22..f5ac9b640d 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/erlang/querying.md @@ -215,9 +215,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.0/developing/getting-started/golang/querying.md b/content/riak/kv/2.0.0/developing/getting-started/golang/querying.md index d7d7f90655..3474414cd1 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/golang/querying.md @@ -416,9 +416,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: diff --git a/content/riak/kv/2.0.0/developing/getting-started/java/querying.md b/content/riak/kv/2.0.0/developing/getting-started/java/querying.md index d140bde6b9..614647d7a8 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/java/querying.md @@ -194,9 +194,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.0/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.0.0/developing/getting-started/nodejs/querying.md index 636a040cf9..dd42f76e4b 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/nodejs/querying.md @@ -87,9 +87,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.0/developing/getting-started/php/querying.md b/content/riak/kv/2.0.0/developing/getting-started/php/querying.md index 222b8becac..e775c04b61 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/php/querying.md @@ -298,9 +298,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.0/developing/getting-started/python/querying.md b/content/riak/kv/2.0.0/developing/getting-started/python/querying.md index d8bee38d07..b88a7d0a1e 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/python/querying.md @@ -181,9 +181,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.0/developing/getting-started/ruby/querying.md b/content/riak/kv/2.0.0/developing/getting-started/ruby/querying.md index 8e3a10ea6c..07bee6ed08 100644 --- a/content/riak/kv/2.0.0/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.0.0/developing/getting-started/ruby/querying.md @@ -191,9 +191,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.1/developing/getting-started/csharp/querying.md b/content/riak/kv/2.0.1/developing/getting-started/csharp/querying.md index 3428f3932f..0e5da5d4ae 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/csharp/querying.md @@ -125,9 +125,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.1/developing/getting-started/erlang/querying.md b/content/riak/kv/2.0.1/developing/getting-started/erlang/querying.md index 0c5f992e5a..39ceab20ee 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/erlang/querying.md @@ -215,9 +215,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.1/developing/getting-started/golang/querying.md b/content/riak/kv/2.0.1/developing/getting-started/golang/querying.md index 9d8384b841..9ecf13959e 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/golang/querying.md @@ -416,9 +416,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: diff --git a/content/riak/kv/2.0.1/developing/getting-started/java/querying.md b/content/riak/kv/2.0.1/developing/getting-started/java/querying.md index 97d5d6d781..2462579344 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/java/querying.md @@ -194,9 +194,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.1/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.0.1/developing/getting-started/nodejs/querying.md index 1e65e14887..4c5f1367a6 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/nodejs/querying.md @@ -87,9 +87,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.1/developing/getting-started/php/querying.md b/content/riak/kv/2.0.1/developing/getting-started/php/querying.md index b489300aae..5babec52f2 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/php/querying.md @@ -298,9 +298,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.1/developing/getting-started/python/querying.md b/content/riak/kv/2.0.1/developing/getting-started/python/querying.md index f2a743a54c..0573e70f12 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/python/querying.md @@ -181,9 +181,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.1/developing/getting-started/ruby/querying.md b/content/riak/kv/2.0.1/developing/getting-started/ruby/querying.md index 8da99a6a6d..bd6a2c3aac 100644 --- a/content/riak/kv/2.0.1/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.0.1/developing/getting-started/ruby/querying.md @@ -191,9 +191,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.2/developing/getting-started/csharp/querying.md b/content/riak/kv/2.0.2/developing/getting-started/csharp/querying.md index f0240271ea..5a98bde506 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/csharp/querying.md @@ -125,9 +125,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.2/developing/getting-started/erlang/querying.md b/content/riak/kv/2.0.2/developing/getting-started/erlang/querying.md index fa8f3281de..a1cd0ebaae 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/erlang/querying.md @@ -215,9 +215,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.2/developing/getting-started/golang/querying.md b/content/riak/kv/2.0.2/developing/getting-started/golang/querying.md index 578d66639a..1fe004394f 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/golang/querying.md @@ -416,9 +416,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: diff --git a/content/riak/kv/2.0.2/developing/getting-started/java/querying.md b/content/riak/kv/2.0.2/developing/getting-started/java/querying.md index 7ac1f1b4c6..31d94a2a72 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/java/querying.md @@ -194,9 +194,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.2/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.0.2/developing/getting-started/nodejs/querying.md index 76cb4e53bb..1618569c0f 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/nodejs/querying.md @@ -87,9 +87,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.2/developing/getting-started/php/querying.md b/content/riak/kv/2.0.2/developing/getting-started/php/querying.md index ae16a7dd3c..e254e0af37 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/php/querying.md @@ -298,9 +298,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.2/developing/getting-started/python/querying.md b/content/riak/kv/2.0.2/developing/getting-started/python/querying.md index 221d33645d..f330d71869 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/python/querying.md @@ -181,9 +181,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.2/developing/getting-started/ruby/querying.md b/content/riak/kv/2.0.2/developing/getting-started/ruby/querying.md index 68c0869828..9c6e2e922f 100644 --- a/content/riak/kv/2.0.2/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.0.2/developing/getting-started/ruby/querying.md @@ -191,9 +191,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.2/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.2/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.2/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.2/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.4/developing/getting-started/csharp/querying.md b/content/riak/kv/2.0.4/developing/getting-started/csharp/querying.md index d23906b38c..7e4f4d7f51 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/csharp/querying.md @@ -125,9 +125,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.4/developing/getting-started/erlang/querying.md b/content/riak/kv/2.0.4/developing/getting-started/erlang/querying.md index 231db10deb..aa0959f8a4 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/erlang/querying.md @@ -215,9 +215,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.4/developing/getting-started/golang/querying.md b/content/riak/kv/2.0.4/developing/getting-started/golang/querying.md index a59ad56d25..91002b5ba9 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/golang/querying.md @@ -416,9 +416,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: diff --git a/content/riak/kv/2.0.4/developing/getting-started/java/querying.md b/content/riak/kv/2.0.4/developing/getting-started/java/querying.md index 4fc143876f..14c1ed66a5 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/java/querying.md @@ -194,9 +194,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.4/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.0.4/developing/getting-started/nodejs/querying.md index 173fe8da3a..917dd157ed 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/nodejs/querying.md @@ -87,9 +87,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.4/developing/getting-started/php/querying.md b/content/riak/kv/2.0.4/developing/getting-started/php/querying.md index d3d9252a77..cf57bf30c4 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/php/querying.md @@ -298,9 +298,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.4/developing/getting-started/python/querying.md b/content/riak/kv/2.0.4/developing/getting-started/python/querying.md index 68b274192d..a7c3997223 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/python/querying.md @@ -181,9 +181,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.4/developing/getting-started/ruby/querying.md b/content/riak/kv/2.0.4/developing/getting-started/ruby/querying.md index 17b3658cc4..8b458a40b9 100644 --- a/content/riak/kv/2.0.4/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.0.4/developing/getting-started/ruby/querying.md @@ -191,9 +191,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.5/developing/getting-started/csharp/querying.md b/content/riak/kv/2.0.5/developing/getting-started/csharp/querying.md index 060f346121..db9e8d4a15 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/csharp/querying.md @@ -125,9 +125,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.5/developing/getting-started/erlang/querying.md b/content/riak/kv/2.0.5/developing/getting-started/erlang/querying.md index 752522199a..59161518c4 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/erlang/querying.md @@ -215,9 +215,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.5/developing/getting-started/golang/querying.md b/content/riak/kv/2.0.5/developing/getting-started/golang/querying.md index 92613c168a..56be89b6fe 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/golang/querying.md @@ -416,9 +416,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: diff --git a/content/riak/kv/2.0.5/developing/getting-started/java/querying.md b/content/riak/kv/2.0.5/developing/getting-started/java/querying.md index de82b0d3f9..19f24c8c30 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/java/querying.md @@ -194,9 +194,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.5/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.0.5/developing/getting-started/nodejs/querying.md index 6acf7d2d43..bec2777dc8 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/nodejs/querying.md @@ -87,9 +87,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.5/developing/getting-started/php/querying.md b/content/riak/kv/2.0.5/developing/getting-started/php/querying.md index fbe65d5071..15ec3e033c 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/php/querying.md @@ -298,9 +298,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.5/developing/getting-started/python/querying.md b/content/riak/kv/2.0.5/developing/getting-started/python/querying.md index 756857bbf0..69d651f4be 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/python/querying.md @@ -181,9 +181,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.5/developing/getting-started/ruby/querying.md b/content/riak/kv/2.0.5/developing/getting-started/ruby/querying.md index fbadb82681..7e5d03ebb3 100644 --- a/content/riak/kv/2.0.5/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.0.5/developing/getting-started/ruby/querying.md @@ -191,9 +191,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.5/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.5/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.5/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.5/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.6/developing/getting-started/csharp/querying.md b/content/riak/kv/2.0.6/developing/getting-started/csharp/querying.md index ade351a613..28a59a9513 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/csharp/querying.md @@ -125,9 +125,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.6/developing/getting-started/erlang/querying.md b/content/riak/kv/2.0.6/developing/getting-started/erlang/querying.md index 4dd62cd66d..cd4bca3a83 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/erlang/querying.md @@ -215,9 +215,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.6/developing/getting-started/golang/querying.md b/content/riak/kv/2.0.6/developing/getting-started/golang/querying.md index aa54832018..1010d94d14 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/golang/querying.md @@ -416,9 +416,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: diff --git a/content/riak/kv/2.0.6/developing/getting-started/java/querying.md b/content/riak/kv/2.0.6/developing/getting-started/java/querying.md index c0538fb9ed..25a032c9af 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/java/querying.md @@ -194,9 +194,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.6/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.0.6/developing/getting-started/nodejs/querying.md index cc205d1f37..b7ca26120f 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/nodejs/querying.md @@ -87,9 +87,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.6/developing/getting-started/php/querying.md b/content/riak/kv/2.0.6/developing/getting-started/php/querying.md index 87e03b4700..59484505eb 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/php/querying.md @@ -298,9 +298,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.6/developing/getting-started/python/querying.md b/content/riak/kv/2.0.6/developing/getting-started/python/querying.md index 228e2ceb06..42c2298137 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/python/querying.md @@ -181,9 +181,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.6/developing/getting-started/ruby/querying.md b/content/riak/kv/2.0.6/developing/getting-started/ruby/querying.md index 6eb03aa97b..fac4e6d2db 100644 --- a/content/riak/kv/2.0.6/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.0.6/developing/getting-started/ruby/querying.md @@ -191,9 +191,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.6/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.6/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.6/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.6/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.7/developing/getting-started/csharp/querying.md b/content/riak/kv/2.0.7/developing/getting-started/csharp/querying.md index c994d9b943..b35f784edf 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/csharp/querying.md @@ -125,9 +125,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.7/developing/getting-started/erlang/querying.md b/content/riak/kv/2.0.7/developing/getting-started/erlang/querying.md index 5f78769863..52e6efecba 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/erlang/querying.md @@ -215,9 +215,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.7/developing/getting-started/golang/querying.md b/content/riak/kv/2.0.7/developing/getting-started/golang/querying.md index c1c2080c30..c6d96881e2 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/golang/querying.md @@ -416,9 +416,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: diff --git a/content/riak/kv/2.0.7/developing/getting-started/java/querying.md b/content/riak/kv/2.0.7/developing/getting-started/java/querying.md index 3665cb4fe9..b4764ed58f 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/java/querying.md @@ -194,9 +194,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.7/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.0.7/developing/getting-started/nodejs/querying.md index fee559b5a4..e9af4cea2c 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/nodejs/querying.md @@ -87,9 +87,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.0.7/developing/getting-started/php/querying.md b/content/riak/kv/2.0.7/developing/getting-started/php/querying.md index 3d742c16dd..22e3d1347a 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/php/querying.md @@ -298,9 +298,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.7/developing/getting-started/python/querying.md b/content/riak/kv/2.0.7/developing/getting-started/python/querying.md index 13b88d8b1f..0700ba4e2a 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/python/querying.md @@ -181,9 +181,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.0.7/developing/getting-started/ruby/querying.md b/content/riak/kv/2.0.7/developing/getting-started/ruby/querying.md index e7b141f9ec..c71abcf42f 100644 --- a/content/riak/kv/2.0.7/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.0.7/developing/getting-started/ruby/querying.md @@ -191,9 +191,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.0.7/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.0.7/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.0.7/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.0.7/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.1.1/developing/getting-started/csharp/querying.md b/content/riak/kv/2.1.1/developing/getting-started/csharp/querying.md index 732ec554c7..5b71420a93 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/csharp/querying.md @@ -125,9 +125,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.1.1/developing/getting-started/erlang/querying.md b/content/riak/kv/2.1.1/developing/getting-started/erlang/querying.md index 4c6a4a29ef..ce213ec3e6 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/erlang/querying.md @@ -215,9 +215,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.1.1/developing/getting-started/golang/querying.md b/content/riak/kv/2.1.1/developing/getting-started/golang/querying.md index 419ff3ec02..acf2943cdf 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/golang/querying.md @@ -416,9 +416,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: diff --git a/content/riak/kv/2.1.1/developing/getting-started/java/querying.md b/content/riak/kv/2.1.1/developing/getting-started/java/querying.md index 69ab4ac633..16a861999c 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/java/querying.md @@ -194,9 +194,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.1.1/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.1.1/developing/getting-started/nodejs/querying.md index e6e143d829..fcfcada91a 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/nodejs/querying.md @@ -87,9 +87,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.1.1/developing/getting-started/php/querying.md b/content/riak/kv/2.1.1/developing/getting-started/php/querying.md index 58a986c24d..64a28e15f7 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/php/querying.md @@ -298,9 +298,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.1.1/developing/getting-started/python/querying.md b/content/riak/kv/2.1.1/developing/getting-started/python/querying.md index 9bbda8f352..f1b32368e2 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/python/querying.md @@ -181,9 +181,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.1.1/developing/getting-started/ruby/querying.md b/content/riak/kv/2.1.1/developing/getting-started/ruby/querying.md index de65af7522..a5a7ebf7e5 100644 --- a/content/riak/kv/2.1.1/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.1.1/developing/getting-started/ruby/querying.md @@ -191,9 +191,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.1/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.1/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.1/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.1/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.1.3/developing/getting-started/csharp/querying.md b/content/riak/kv/2.1.3/developing/getting-started/csharp/querying.md index 2c027c43a6..26cf7fea2b 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/csharp/querying.md @@ -125,9 +125,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.1.3/developing/getting-started/erlang/querying.md b/content/riak/kv/2.1.3/developing/getting-started/erlang/querying.md index 8a23c86aac..dcde354c2b 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/erlang/querying.md @@ -215,9 +215,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.1.3/developing/getting-started/golang/querying.md b/content/riak/kv/2.1.3/developing/getting-started/golang/querying.md index 18374bba84..7a196bb431 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/golang/querying.md @@ -416,9 +416,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: diff --git a/content/riak/kv/2.1.3/developing/getting-started/java/querying.md b/content/riak/kv/2.1.3/developing/getting-started/java/querying.md index 6a9069ceb5..28a57a3ccd 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/java/querying.md @@ -194,9 +194,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.1.3/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.1.3/developing/getting-started/nodejs/querying.md index 21ddbe3244..f88789a525 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/nodejs/querying.md @@ -87,9 +87,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.1.3/developing/getting-started/php/querying.md b/content/riak/kv/2.1.3/developing/getting-started/php/querying.md index e7984b4d6b..99430740e2 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/php/querying.md @@ -298,9 +298,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.1.3/developing/getting-started/python/querying.md b/content/riak/kv/2.1.3/developing/getting-started/python/querying.md index 46d89f93dc..0c5e0cf758 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/python/querying.md @@ -181,9 +181,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.1.3/developing/getting-started/ruby/querying.md b/content/riak/kv/2.1.3/developing/getting-started/ruby/querying.md index 6230cf2e8f..abaf73bf97 100644 --- a/content/riak/kv/2.1.3/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.1.3/developing/getting-started/ruby/querying.md @@ -191,9 +191,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.3/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.3/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.3/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.3/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.1.4/developing/getting-started/csharp/querying.md b/content/riak/kv/2.1.4/developing/getting-started/csharp/querying.md index d93e4d53d8..3fa6c49e7f 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/csharp/querying.md @@ -125,9 +125,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.1.4/developing/getting-started/erlang/querying.md b/content/riak/kv/2.1.4/developing/getting-started/erlang/querying.md index 17323c4743..1874ef25f0 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/erlang/querying.md @@ -215,9 +215,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.1.4/developing/getting-started/golang/querying.md b/content/riak/kv/2.1.4/developing/getting-started/golang/querying.md index 10fcb43a6b..05ce11d200 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/golang/querying.md @@ -416,9 +416,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: diff --git a/content/riak/kv/2.1.4/developing/getting-started/java/querying.md b/content/riak/kv/2.1.4/developing/getting-started/java/querying.md index a4ca64ff09..b5d6d19181 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/java/querying.md @@ -194,9 +194,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.1.4/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.1.4/developing/getting-started/nodejs/querying.md index 3bd4044190..e374aa2bc3 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/nodejs/querying.md @@ -87,9 +87,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.1.4/developing/getting-started/php/querying.md b/content/riak/kv/2.1.4/developing/getting-started/php/querying.md index dd65743094..5eced10f00 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/php/querying.md @@ -298,9 +298,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.1.4/developing/getting-started/python/querying.md b/content/riak/kv/2.1.4/developing/getting-started/python/querying.md index c113d2e196..e01b91a3c1 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/python/querying.md @@ -181,9 +181,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.1.4/developing/getting-started/ruby/querying.md b/content/riak/kv/2.1.4/developing/getting-started/ruby/querying.md index 778182360a..83c22d66bc 100644 --- a/content/riak/kv/2.1.4/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.1.4/developing/getting-started/ruby/querying.md @@ -191,9 +191,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.1.4/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.1.4/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.1.4/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.1.4/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.2.0/developing/getting-started/csharp/querying.md b/content/riak/kv/2.2.0/developing/getting-started/csharp/querying.md index efbd6c8daf..1146011c46 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/csharp/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/csharp/querying.md @@ -125,9 +125,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.2.0/developing/getting-started/erlang/querying.md b/content/riak/kv/2.2.0/developing/getting-started/erlang/querying.md index c218be8f87..027c338347 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/erlang/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/erlang/querying.md @@ -215,9 +215,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.2.0/developing/getting-started/golang/querying.md b/content/riak/kv/2.2.0/developing/getting-started/golang/querying.md index 2bbd7b124a..9ee0ef717f 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/golang/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/golang/querying.md @@ -416,9 +416,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly look up objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values or ranges of values. To properly show this off, we will add some more data to our application, and add some secondary index entries at the same time: diff --git a/content/riak/kv/2.2.0/developing/getting-started/java/querying.md b/content/riak/kv/2.2.0/developing/getting-started/java/querying.md index b343bbb872..6fb130d97c 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/java/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/java/querying.md @@ -194,9 +194,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.2.0/developing/getting-started/nodejs/querying.md b/content/riak/kv/2.2.0/developing/getting-started/nodejs/querying.md index 7d55f75a64..feec1029b0 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/nodejs/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/nodejs/querying.md @@ -87,9 +87,9 @@ intrinsic relationships. ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from an SQL world, Secondary Indexes (2i) are a lot diff --git a/content/riak/kv/2.2.0/developing/getting-started/php/querying.md b/content/riak/kv/2.2.0/developing/getting-started/php/querying.md index f0506f9f48..a37f334126 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/php/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/php/querying.md @@ -298,9 +298,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ## Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.2.0/developing/getting-started/python/querying.md b/content/riak/kv/2.2.0/developing/getting-started/python/querying.md index 22a39a56fc..bedeb1c6ba 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/python/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/python/querying.md @@ -181,9 +181,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time. diff --git a/content/riak/kv/2.2.0/developing/getting-started/ruby/querying.md b/content/riak/kv/2.2.0/developing/getting-started/ruby/querying.md index d0daaa346a..2a925735cb 100644 --- a/content/riak/kv/2.2.0/developing/getting-started/ruby/querying.md +++ b/content/riak/kv/2.2.0/developing/getting-started/ruby/querying.md @@ -191,9 +191,9 @@ While this pattern is very easy and extremely fast with respect to queries and c ### Secondary Indexes {{% note %}} -Secondary Indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support Secondary Indexes. +Secondary indexes in Riak KV require a sorted backend: [Memory](/riak/kv/2.2.0/setup/planning/backend/memory) or [LevelDB](/riak/kv/2.2.0/setup/planning/backend/leveldb). [Bitcask](/riak/kv/2.2.0/setup/planning/backend/bitcask) does not support secondary indexes. -See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with Secondary Indexes. +See [Using Secondary Indexes (2i)](/riak/kv/2.2.0/developing/usage/secondary-indexes) for more information on developing with secondary indexes. {{% /note %}} If you're coming from a SQL world, Secondary Indexes (2i) are a lot like SQL indexes. They are a way to quickly lookup objects based on a secondary key, without scanning through the whole dataset. This makes it very easy to find groups of related data by values, or even ranges of values. To properly show this off, we will now add some more data to our application, and add some secondary index entries at the same time.