http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/partitioned_regions/rebalancing_pr_data.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/partitioned_regions/rebalancing_pr_data.html.md.erb 
b/geode-docs/developing/partitioned_regions/rebalancing_pr_data.html.md.erb
index d40a4f2..66057a4 100644
--- a/geode-docs/developing/partitioned_regions/rebalancing_pr_data.html.md.erb
+++ b/geode-docs/developing/partitioned_regions/rebalancing_pr_data.html.md.erb
@@ -34,7 +34,7 @@ If you have transactions running in your system, be careful 
in planning your reb
 
 Kick off a rebalance using one of the following:
 
--   `gfsh` command. First, starting a `gfsh` prompt and connect to the Geode 
distributed system. Then type the following command:
+-   `gfsh` command. First, starting a `gfsh` prompt and connect to the 
<%=vars.product_name%> distributed system. Then type the following command:
 
     ``` pre
     gfsh>rebalance
@@ -70,11 +70,11 @@ The rebalancing operation runs asynchronously.
 
 By default, rebalancing is performed on one partitioned region at a time. For 
regions that have colocated data, the rebalancing works on the regions as a 
group, maintaining the data colocation between the regions.
 
-You can optionally rebalance multiple regions in parallel by setting the 
`gemfire.resource.manager.threads` system property. Setting this property to a 
value greater than 1 enables Geode to rebalance multiple regions in parallel, 
any time a rebalance operation is initiated using the API.
+You can optionally rebalance multiple regions in parallel by setting the 
`gemfire.resource.manager.threads` system property. Setting this property to a 
value greater than 1 enables <%=vars.product_name%> to rebalance multiple 
regions in parallel, any time a rebalance operation is initiated using the API.
 
 You can continue to use your partitioned regions normally while rebalancing is 
in progress. Read operations, write operations, and function executions 
continue while data is moving. If a function is executing on a local data set, 
you may see a performance degradation if that data moves to another host during 
function execution. Future function invocations are routed to the correct 
member.
 
-Geode tries to ensure that each member has the same percentage of its 
available space used for each partitioned region. The percentage is configured 
in the `partition-attributes` `local-max-memory` setting.
+<%=vars.product_name%> tries to ensure that each member has the same 
percentage of its available space used for each partitioned region. The 
percentage is configured in the `partition-attributes` `local-max-memory` 
setting.
 
 Partitioned region rebalancing:
 
@@ -89,7 +89,7 @@ You typically want to trigger rebalancing when capacity is 
increased or reduced
 
 You may also need to rebalance when:
 
--   You use redundancy for high availability and have configured your region 
to not automatically recover redundancy after a loss. In this case, Geode only 
restores redundancy when you invoke a rebalance. See [Configure High 
Availability for a Partitioned Region](configuring_ha_for_pr.html).
+-   You use redundancy for high availability and have configured your region 
to not automatically recover redundancy after a loss. In this case, 
<%=vars.product_name%> only restores redundancy when you invoke a rebalance. 
See [Configure High Availability for a Partitioned 
Region](configuring_ha_for_pr.html).
 -   You have uneven hashing of data. Uneven hashing can occur if your keys do 
not have a hash code method, which ensures uniform distribution, or if you use 
a `PartitionResolver` to colocate your partitioned region data (see [Colocate 
Data from Different Partitioned 
Regions](colocating_partitioned_region_data.html#colocating_partitioned_region_data)).
 In either case, some buckets may receive more data than others. Rebalancing 
can be used to even out the load between data stores by putting fewer buckets 
on members that are hosting large buckets.
 
 ## <a id="rebalancing_pr_data__section_495FEE48ED60433BADB7D36C73279C89" 
class="no-quick-link"></a>How to Simulate Region Rebalancing

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/partitioned_regions/set_enforce_unique_host.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/partitioned_regions/set_enforce_unique_host.html.md.erb 
b/geode-docs/developing/partitioned_regions/set_enforce_unique_host.html.md.erb
index 000216c..fdfaf5a 100644
--- 
a/geode-docs/developing/partitioned_regions/set_enforce_unique_host.html.md.erb
+++ 
b/geode-docs/developing/partitioned_regions/set_enforce_unique_host.html.md.erb
@@ -19,11 +19,11 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-Configure Geode to use only unique physical machines for redundant copies of 
partitioned region data.
+Configure <%=vars.product_name%> to use only unique physical machines for 
redundant copies of partitioned region data.
 
 Understand how to set a member's `gemfire.properties` settings. See 
[Reference](../../reference/book_intro.html#reference).
 
-Configure your members so Geode always uses different physical machines for 
redundant copies of partitioned region data using the `gemfire.properties` 
setting `enforce-unique-host`. The default for this setting is false. 
+Configure your members so <%=vars.product_name%> always uses different 
physical machines for redundant copies of partitioned region data using the 
`gemfire.properties` setting `enforce-unique-host`. The default for this 
setting is false. 
 
 Example:
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/partitioned_regions/set_redundancy_zones.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/partitioned_regions/set_redundancy_zones.html.md.erb 
b/geode-docs/developing/partitioned_regions/set_redundancy_zones.html.md.erb
index e08be5d..d4d3838 100644
--- a/geode-docs/developing/partitioned_regions/set_redundancy_zones.html.md.erb
+++ b/geode-docs/developing/partitioned_regions/set_redundancy_zones.html.md.erb
@@ -19,7 +19,7 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-Group members into redundancy zones so Geode will separate redundant data 
copies into different zones.
+Group members into redundancy zones so <%=vars.product_name%> will separate 
redundant data copies into different zones.
 
 Understand how to set a member's `gemfire.properties` settings. See 
[Reference](../../reference/book_intro.html#reference).
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/partitioned_regions/using_custom_partition_resolvers.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/partitioned_regions/using_custom_partition_resolvers.html.md.erb
 
b/geode-docs/developing/partitioned_regions/using_custom_partition_resolvers.html.md.erb
index 40b2237..44b45d8 100644
--- 
a/geode-docs/developing/partitioned_regions/using_custom_partition_resolvers.html.md.erb
+++ 
b/geode-docs/developing/partitioned_regions/using_custom_partition_resolvers.html.md.erb
@@ -19,7 +19,7 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-By default, Geode partitions each data entry into a bucket using a hashing 
policy on the key. Additionally, the physical location of the key-value pair is 
abstracted away from the application. You can change these policies for a 
partitioned region. You can provide your own data partitioning resolver and you 
can additionally specify which members host which data buckets.
+By default, <%=vars.product_name%> partitions each data entry into a bucket 
using a hashing policy on the key. Additionally, the physical location of the 
key-value pair is abstracted away from the application. You can change these 
policies for a partitioned region. You can provide your own data partitioning 
resolver and you can additionally specify which members host which data buckets.
 
 <a 
id="custom_partition_region_data__section_CF05CE974C9C4AF78430DA55601D2158"></a>
 **Note:**
@@ -40,7 +40,7 @@ For standard partitioning, use 
`org.apache.geode.cache.PartitionResolver`. To im
 
 **Procedure**
 
-1.  If using `org.apache.geode.cache.PartitionResolver` (standard 
partitioning) or `org.apache.geode.cache.FixedPartitionResolver` (fixed 
partitioning), implement the standard partitioning resolver or the fixed 
partitioning resolver in one of the following locations, listed here in the 
search order used by Geode:
+1.  If using `org.apache.geode.cache.PartitionResolver` (standard 
partitioning) or `org.apache.geode.cache.FixedPartitionResolver` (fixed 
partitioning), implement the standard partitioning resolver or the fixed 
partitioning resolver in one of the following locations, listed here in the 
search order used by <%=vars.product_name%>:
     -   **Custom class**. You provide this class as the partition resolver to 
the region creation.
     -   **Entry key**. You use the implementing key object for every operation 
on the region entries.
     -   **Cache callback argument**. This implementation restricts you to 
using methods that accept a cache callback argument to manage the region 
entries. For a full list of the methods that take a callback argument, see the 
`Region` Javadocs.
@@ -54,7 +54,7 @@ function that partitions the entry.
 2.  If you need the resolver's `getName` method, program that.
 3.  If *not* using the default implementation of the string-based
 partition resolver,
-program the resolver's `getRoutingObject` method to return the routing object 
for each entry, based on how you want to group the entries. Give the same 
routing object to entries you want to group together. Geode will place the 
entries in the same bucket.
+program the resolver's `getRoutingObject` method to return the routing object 
for each entry, based on how you want to group the entries. Give the same 
routing object to entries you want to group together. <%=vars.product_name%> 
will place the entries in the same bucket.
 
     **Note:**
     Only fields on the key should be used when creating the routing object. Do 
not use the value or additional metadata for this purpose.
@@ -130,7 +130,7 @@ program the resolver's `getRoutingObject` method to return 
the routing object fo
 
             You cannot specify a partition resolver using gfsh.
 
-    2.  Program the `FixedPartitionResolver` `getPartitionName` method to 
return the name of the partition for each entry, based on where you want the 
entries to reside. Geode uses `getPartitionName` and `getRoutingObject` to 
determine where an entry is placed.
+    2.  Program the `FixedPartitionResolver` `getPartitionName` method to 
return the name of the partition for each entry, based on where you want the 
entries to reside. <%=vars.product_name%> uses `getPartitionName` and 
`getRoutingObject` to determine where an entry is placed.
 
         **Note:**
         To group entries, assign every entry in the group the same routing 
object and the same partition name.
@@ -188,7 +188,7 @@ program the resolver's `getRoutingObject` method to return 
the routing object fo
         }
         ```
 
-5.  Configure or program the region so Geode finds your resolver for every 
operation that you perform on the region's entries. How you do this depends on 
where you chose to program your custom partitioning implementation (step 1).
+5.  Configure or program the region so <%=vars.product_name%> finds your 
resolver for every operation that you perform on the region's entries. How you 
do this depends on where you chose to program your custom partitioning 
implementation (step 1).
     -   **Custom class**. Define the class for the region at creation. The 
resolver will be used for every entry operation. Use one of these methods:
 
         **XML:**

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_additional/advanced_querying.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/query_additional/advanced_querying.html.md.erb 
b/geode-docs/developing/query_additional/advanced_querying.html.md.erb
index 7054868..ce758a2 100644
--- a/geode-docs/developing/query_additional/advanced_querying.html.md.erb
+++ b/geode-docs/developing/query_additional/advanced_querying.html.md.erb
@@ -21,27 +21,27 @@ limitations under the License.
 
 This section includes advanced querying topics such as using query indexes, 
using query bind parameters, querying partitioned regions and query debugging.
 
--   **[Performance 
Considerations](../../developing/querying_basics/performance_considerations.html)**
+-   **[Performance 
Considerations](../querying_basics/performance_considerations.html)**
 
     This topic covers considerations for improving query performance.
 
--   **[Monitoring Queries for Low 
Memory](../../developing/querying_basics/monitor_queries_for_low_memory.html)**
+-   **[Monitoring Queries for Low 
Memory](../querying_basics/monitor_queries_for_low_memory.html)**
 
     The query monitoring feature prevents out-of-memory exceptions from 
occurring when you execute queries or create indexes.
 
--   **[Using Query Bind 
Parameters](../../developing/query_additional/using_query_bind_parameters.html)**
+-   **[Using Query Bind 
Parameters](../query_additional/using_query_bind_parameters.html)**
 
-    Using query bind parameters in Geode queries is similar to using prepared 
statements in SQL where parameters can be set during query execution. This 
allows user to build a query once and execute it multiple times by passing the 
query conditions during run time.
+    Using query bind parameters in <%=vars.product_name%> queries is similar 
to using prepared statements in SQL where parameters can be set during query 
execution. This allows user to build a query once and execute it multiple times 
by passing the query conditions during run time.
 
--   **[Working with Indexes](../../developing/query_index/query_index.html)**
+-   **[Working with Indexes](../query_index/query_index.html)**
 
-    The Geode query engine supports indexing. An index can provide significant 
performance gains for query execution.
+    The <%=vars.product_name%> query engine supports indexing. An index can 
provide significant performance gains for query execution.
 
--   **[Querying Partitioned 
Regions](../../developing/querying_basics/querying_partitioned_regions.html)**
+-   **[Querying Partitioned 
Regions](../querying_basics/querying_partitioned_regions.html)**
 
-    Geode allows you to manage and store large amounts of data across 
distributed nodes using partitioned regions. The basic unit of storage for a 
partitioned region is a bucket, which resides on a Geode node and contains all 
the entries that map to a single hashcode. In a typical partitioned region 
query, the system distributes the query to all buckets across all nodes, then 
merges the result sets and sends back the query results.
+    <%=vars.product_name%> allows you to manage and store large amounts of 
data across distributed nodes using partitioned regions. The basic unit of 
storage for a partitioned region is a bucket, which resides on a 
<%=vars.product_name%> node and contains all the entries that map to a single 
hashcode. In a typical partitioned region query, the system distributes the 
query to all buckets across all nodes, then merges the result sets and sends 
back the query results.
 
--   **[Query 
Debugging](../../developing/query_additional/query_debugging.html)**
+-   **[Query Debugging](../query_additional/query_debugging.html)**
 
     You can debug a specific query at the query level by adding the `<trace>` 
keyword before the query string that you want to debug.
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_additional/literals.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/query_additional/literals.html.md.erb 
b/geode-docs/developing/query_additional/literals.html.md.erb
index e86371c..40c4434 100644
--- a/geode-docs/developing/query_additional/literals.html.md.erb
+++ b/geode-docs/developing/query_additional/literals.html.md.erb
@@ -21,7 +21,7 @@ limitations under the License.
 
 ## <a id="literals__section_BA2D0AC444EB45088F00D9E2C8A1DD06" 
class="no-quick-link"></a>Comparing Values With java.util.Date
 
-Geode supports the following literal types:
+<%=vars.product_name%> supports the following literal types:
 
 <dt>**boolean**</dt>
 <dd>A `boolean` value, either TRUE or FALSE</dd>
@@ -51,7 +51,7 @@ You can compare temporal literal values `DATE`, `TIME`, and 
`TIMESTAMP` with `ja
 
 ## <a id="literals__section_9EE6CFC410D2409188EDEAA43AC85851" 
class="no-quick-link"></a>Type Conversion
 
-The Geode query processor performs implicit type conversions and promotions 
under certain cases in order to evaluate expressions that contain different 
types. The query processor performs binary numeric promotion, method invocation 
conversion, and temporal type conversion.
+The <%=vars.product_name%> query processor performs implicit type conversions 
and promotions under certain cases in order to evaluate expressions that 
contain different types. The query processor performs binary numeric promotion, 
method invocation conversion, and temporal type conversion.
 
 ## <a id="literals__section_F5A3FC509FD04E09B5468BA94B814701" 
class="no-quick-link"></a>Binary Numeric Promotion
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_additional/operators.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/query_additional/operators.html.md.erb 
b/geode-docs/developing/query_additional/operators.html.md.erb
index e8cca37..a4a3d8d 100644
--- a/geode-docs/developing/query_additional/operators.html.md.erb
+++ b/geode-docs/developing/query_additional/operators.html.md.erb
@@ -19,7 +19,7 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-Geode supports comparison, logical, unary, map, index, dot, and right arrow 
operators.
+<%=vars.product_name%> supports comparison, logical, unary, map, index, dot, 
and right arrow operators.
 
 ## <a id="operators__section_A3FB372F85D840D7A49CB95BD7FCA7C6" 
class="no-quick-link"></a>Comparison Operators
 
@@ -42,7 +42,7 @@ The logical operators AND and OR allow you to create more 
complex expressions by
 
 ## <a id="operators__section_A970AE75B0D24E0B9E1B61BE2D9842D8" 
class="no-quick-link"></a>Unary Operators
 
-Unary operators operate on a single value or expression, and have lower 
precedence than comparison operators in expressions. Geode supports the unary 
operator NOT. NOT is the negation operator, which changes the value of the 
operand to its opposite. So if an expression evaluates to TRUE, NOT changes it 
to FALSE. The operand must be a boolean.
+Unary operators operate on a single value or expression, and have lower 
precedence than comparison operators in expressions. <%=vars.product_name%> 
supports the unary operator NOT. NOT is the negation operator, which changes 
the value of the operand to its opposite. So if an expression evaluates to 
TRUE, NOT changes it to FALSE. The operand must be a boolean.
 
 ## <a id="operators__section_E78FB4FB3703471C8186A0E26D25F01F" 
class="no-quick-link"></a>Map and Index Operators
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_additional/query_debugging.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/query_additional/query_debugging.html.md.erb 
b/geode-docs/developing/query_additional/query_debugging.html.md.erb
index c404d6b..8ec8703 100644
--- a/geode-docs/developing/query_additional/query_debugging.html.md.erb
+++ b/geode-docs/developing/query_additional/query_debugging.html.md.erb
@@ -33,7 +33,7 @@ You can also write:
 <TRACE> select * from /exampleRegion
 ```
 
-When the query is executed, Geode will log a message in 
`$GEMFIRE_DIR/system.log` with the following information:
+When the query is executed, <%=vars.product_name%> will log a message in 
`$GEMFIRE_DIR/system.log` with the following information:
 
 ``` pre
 [info 2011/08/29 11:24:35.472 PDT CqServer <main> tid=0x1] Query Executed in 
9.619656 ms; rowCount = 99; indexesUsed(0) "select *  from /exampleRegion" 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_additional/query_language_features.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/query_additional/query_language_features.html.md.erb 
b/geode-docs/developing/query_additional/query_language_features.html.md.erb
index 10ab0c6..e9d3602 100644
--- a/geode-docs/developing/query_additional/query_language_features.html.md.erb
+++ b/geode-docs/developing/query_additional/query_language_features.html.md.erb
@@ -22,20 +22,20 @@ limitations under the License.
 <a 
id="concept_5B8BA904DF2A41BEAA057017777D4E90__section_33F0FD791A2448CB812E8397828B33C2"></a>
 This section covers the following querying language features:
 
--   **[Supported Character 
Sets](../../developing/querying_basics/supported_character_sets.html)**
+-   **[Supported Character 
Sets](../querying_basics/supported_character_sets.html)**
 
--   **[Supported 
Keywords](../../developing/query_additional/supported_keywords.html)**
+-   **[Supported Keywords](supported_keywords.html)**
 
--   **[Case 
Sensitivity](../../developing/query_additional/case_sensitivity.html)**
+-   **[Case Sensitivity](case_sensitivity.html)**
 
--   **[Comments in Query 
Strings](../../developing/querying_basics/comments_in_query_strings.html)**
+-   **[Comments in Query 
Strings](../querying_basics/comments_in_query_strings.html)**
 
--   **[Query Language 
Grammar](../../developing/querying_basics/query_grammar_and_reserved_words.html)**
+-   **[Query Language 
Grammar](../querying_basics/query_grammar_and_reserved_words.html)**
 
--   **[Operators](../../developing/query_additional/operators.html)**
+-   **[Operators](operators.html)**
 
--   **[Reserved Words](../../developing/querying_basics/reserved_words.html)**
+-   **[Reserved Words](../querying_basics/reserved_words.html)**
 
--   **[Supported Literals](../../developing/query_additional/literals.html)**
+-   **[Supported Literals](literals.html)**
 
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_additional/using_query_bind_parameters.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/query_additional/using_query_bind_parameters.html.md.erb
 
b/geode-docs/developing/query_additional/using_query_bind_parameters.html.md.erb
index 8fee56b..880d186 100644
--- 
a/geode-docs/developing/query_additional/using_query_bind_parameters.html.md.erb
+++ 
b/geode-docs/developing/query_additional/using_query_bind_parameters.html.md.erb
@@ -19,7 +19,7 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-Using query bind parameters in Geode queries is similar to using prepared 
statements in SQL where parameters can be set during query execution. This 
allows user to build a query once and execute it multiple times by passing the 
query conditions during run time.
+Using query bind parameters in <%=vars.product_name%> queries is similar to 
using prepared statements in SQL where parameters can be set during query 
execution. This allows user to build a query once and execute it multiple times 
by passing the query conditions during run time.
 
 Query objects are thread-safe.
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_index/create_multiple_indexes.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/query_index/create_multiple_indexes.html.md.erb 
b/geode-docs/developing/query_index/create_multiple_indexes.html.md.erb
index e5a15c0..0f8f8af 100644
--- a/geode-docs/developing/query_index/create_multiple_indexes.html.md.erb
+++ b/geode-docs/developing/query_index/create_multiple_indexes.html.md.erb
@@ -61,7 +61,7 @@ Message : Region ' /r3' not found: from  /r3Occurred on 
following members
     List<Index> indexes = queryService.createDefinedIndexes();
 ```
 
-If one or more index population fails, Geode collect the Exceptions and 
continues to populate the rest of the indexes. The collected `Exceptions` are 
stored in a Map of index names and exceptions that can be accessed through 
`MultiIndexCreationException`.
+If one or more index population fails, <%=vars.product_name%> collect the 
Exceptions and continues to populate the rest of the indexes. The collected 
`Exceptions` are stored in a Map of index names and exceptions that can be 
accessed through `MultiIndexCreationException`.
 
 Index definitions are stored locally on the `gfsh` client. If you want to 
create a new set of indexes or if one or more of the index creations fail, you 
might want to clear the definitions stored by using `clear defined 
indexes`command. The defined indexes can be cleared by using the Java API:
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_index/creating_an_index.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/query_index/creating_an_index.html.md.erb 
b/geode-docs/developing/query_index/creating_an_index.html.md.erb
index 2438447..abac6f3 100644
--- a/geode-docs/developing/query_index/creating_an_index.html.md.erb
+++ b/geode-docs/developing/query_index/creating_an_index.html.md.erb
@@ -19,7 +19,7 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-The Geode `QueryService` API provides methods to create, list and remove the 
index. You can also use `gfsh` command-line interface to create, list and 
remove indexes, and use cache.xml to create an index.
+The <%=vars.product_name%> `QueryService` API provides methods to create, list 
and remove the index. You can also use `gfsh` command-line interface to create, 
list and remove indexes, and use cache.xml to create an index.
 
 ## <a id="indexing__section_565C080FBDD0443C8504DF372E3C32C8" 
class="no-quick-link"></a>Creating Indexes
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_index/creating_hash_indexes.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/query_index/creating_hash_indexes.html.md.erb 
b/geode-docs/developing/query_index/creating_hash_indexes.html.md.erb
index bd97e6f..8ee8167 100644
--- a/geode-docs/developing/query_index/creating_hash_indexes.html.md.erb
+++ b/geode-docs/developing/query_index/creating_hash_indexes.html.md.erb
@@ -19,7 +19,7 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-Geode supports the creation of hash indexes for the purposes of performing 
equality-based queries.
+<%=vars.product_name%> supports the creation of hash indexes for the purposes 
of performing equality-based queries.
 
 ## <a 
id="concept_5C7614F71F394C62ACA1BDC5684A7AC4__section_8A927DFB29364DA7856E7FE122FC1654"
 class="no-quick-link"></a>Why Create a HashIndex
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_index/indexing_guidelines.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/query_index/indexing_guidelines.html.md.erb 
b/geode-docs/developing/query_index/indexing_guidelines.html.md.erb
index 88c14b0..4470d97 100644
--- a/geode-docs/developing/query_index/indexing_guidelines.html.md.erb
+++ b/geode-docs/developing/query_index/indexing_guidelines.html.md.erb
@@ -31,7 +31,7 @@ When creating indexes, keep in mind the following:
 
 ## <a id="indexing_guidelines__section_A8AFAA243B5C43DD9BB9F9235A48AF53" 
class="no-quick-link"></a>Tips for Writing Queries that Use Indexes
 
-As with query processors that run against relational databases, the way a 
query is written can greatly affect execution performance. Among other things, 
whether indexes are used depends on how each query is stated. These are some of 
the things to consider when optimizing your Geode queries for performance:
+As with query processors that run against relational databases, the way a 
query is written can greatly affect execution performance. Among other things, 
whether indexes are used depends on how each query is stated. These are some of 
the things to consider when optimizing your <%=vars.product_name%> queries for 
performance:
 
 -   In general an index will improve query performance if the FROM clauses of 
the query and index match exactly.
 -   The query evaluation engine does not have a sophisticated cost-based 
optimizer. It has a simple optimizer which selects best index (one) or multiple 
indexes based on the index size and the operator that is being evaluated.

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_index/maintaining_indexes.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/query_index/maintaining_indexes.html.md.erb 
b/geode-docs/developing/query_index/maintaining_indexes.html.md.erb
index 838f380..8214076 100644
--- a/geode-docs/developing/query_index/maintaining_indexes.html.md.erb
+++ b/geode-docs/developing/query_index/maintaining_indexes.html.md.erb
@@ -52,7 +52,7 @@ Flight {
 }
 ```
 
-An index on the Passenger name field will have different memory space 
requirements in the cache than the Flight origin field even though they are 
both String field types. The internal data structure selected by Geode for 
index storage will depend on the field's level in the object. In this example, 
name is a top-level field and an index on name can be stored as a compact 
index. Since origin is a second-level field, any index that uses origin as the 
indexed expression will be stored as a non-compact index.
+An index on the Passenger name field will have different memory space 
requirements in the cache than the Flight origin field even though they are 
both String field types. The internal data structure selected by 
<%=vars.product_name%> for index storage will depend on the field's level in 
the object. In this example, name is a top-level field and an index on name can 
be stored as a compact index. Since origin is a second-level field, any index 
that uses origin as the indexed expression will be stored as a non-compact 
index.
 
 **Compact Index**
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_index/query_index.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/query_index/query_index.html.md.erb 
b/geode-docs/developing/query_index/query_index.html.md.erb
index 0f2c698..3d53e55 100644
--- a/geode-docs/developing/query_index/query_index.html.md.erb
+++ b/geode-docs/developing/query_index/query_index.html.md.erb
@@ -19,60 +19,60 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-The Geode query engine supports indexing. An index can provide significant 
performance gains for query execution.
+The <%=vars.product_name%> query engine supports indexing. An index can 
provide significant performance gains for query execution.
 
 <a id="indexing__section_565C080FBDD0443C8504DF372E3C32C8"></a>
 A query run without the aid of an index iterates through every object in the 
collection. If an index is available that matches part or all of the query 
specification, the query iterates only over the indexed set, and query 
processing time can be reduced.
 
--   **[Tips and Guidelines on Using 
Indexes](../../developing/query_index/indexing_guidelines.html)**
+-   **[Tips and Guidelines on Using Indexes](indexing_guidelines.html)**
 
     Optimizing your queries with indexes requires a cycle of careful planning, 
testing, and tuning. Poorly-defined indexes can degrade the performance of your 
queries instead of improving it. This section gives guidelines for index usage 
in the query service.
 
--   **[Creating, Listing and Removing 
Indexes](../../developing/query_index/creating_an_index.html)**
+-   **[Creating, Listing and Removing Indexes](creating_an_index.html)**
 
-    The Geode `QueryService` API provides methods to create, list and remove 
the index. You can also use `gfsh` command-line interface to create, list and 
remove indexes, and use cache.xml to create an index.
+    The <%=vars.product_name%> `QueryService` API provides methods to create, 
list and remove the index. You can also use `gfsh` command-line interface to 
create, list and remove indexes, and use cache.xml to create an index.
 
--   **[Creating Key 
Indexes](../../developing/query_index/creating_key_indexes.html)**
+-   **[Creating Key Indexes](creating_key_indexes.html)**
 
     Creating a key index is a good way to improve query performance when data 
is partitioned using a key or a field value. You can create key indexes by 
using the `createKeyIndex` method of the QueryService or by defining the index 
in `cache.xml`. Creating a key index makes the query service aware of the 
relationship between the values in the region and the keys in the region.
 
--   **[Creating Hash 
Indexes](../../developing/query_index/creating_hash_indexes.html)**
+-   **[Creating Hash Indexes](creating_hash_indexes.html)**
 
-    Geode supports the creation of hash indexes for the purposes of performing 
equality-based queries.
+    <%=vars.product_name%> supports the creation of hash indexes for the 
purposes of performing equality-based queries.
 
--   **[Creating Indexes on Map Fields ("Map 
Indexes")](../../developing/query_index/creating_map_indexes.html)**
+-   **[Creating Indexes on Map Fields ("Map 
Indexes")](creating_map_indexes.html)**
 
     To assist with the quick lookup of multiple values in a Map (or HashMap) 
type field, you can create an index (sometimes referred to as a "map index") on 
specific (or all) keys in that field.
 
--   **[Creating Multiple Indexes at 
Once](../../developing/query_index/create_multiple_indexes.html)**
+-   **[Creating Multiple Indexes at Once](create_multiple_indexes.html)**
 
     In order to speed and promote efficiency when creating indexes, you can 
define multiple indexes and then create them all at once.
 
--   **[Maintaining Indexes (Synchronously or Asynchronously) and Index 
Storage](../../developing/query_index/maintaining_indexes.html)**
+-   **[Maintaining Indexes (Synchronously or Asynchronously) and Index 
Storage](maintaining_indexes.html)**
 
     Indexes are automatically kept current with the region data they 
reference. The region attribute `IndexMaintenanceSynchronous` specifies whether 
the region indexes are updated synchronously when a region is modified or 
asynchronously in a background thread.
 
--   **[Using Query Index 
Hints](../../developing/query_index/query_index_hints.html)**
+-   **[Using Query Index Hints](query_index_hints.html)**
 
-    You can use the hint keyword to allow Geode's query engine to prefer 
certain indexes.
+    You can use the hint keyword to allow <%=vars.product_name%>'s query 
engine to prefer certain indexes.
 
--   **[Using Indexes on Single Region 
Queries](../../developing/query_index/indexes_on_single_region_queries.html)**
+-   **[Using Indexes on Single Region 
Queries](indexes_on_single_region_queries.html)**
 
     Queries with one comparison operation may be improved with either a key or 
range index, depending on whether the attribute being compared is also the 
primary key.
 
--   **[Using Indexes with Equi-Join 
Queries](../../developing/query_index/using_indexes_with_equijoin_queries.html)**
+-   **[Using Indexes with Equi-Join 
Queries](using_indexes_with_equijoin_queries.html)**
 
     Equi-join queries are queries in which two regions are joined through an 
equality condition in the WHERE clause.
 
--   **[Using Indexes with Overflow 
Regions](../../developing/query_index/indexes_with_overflow_regions.html)**
+-   **[Using Indexes with Overflow 
Regions](indexes_with_overflow_regions.html)**
 
     You can use indexes when querying on overflow regions; however, there are 
caveats.
 
--   **[Using Indexes on Equi-Join Queries using Multiple 
Regions](../../developing/query_index/using_indexes_with_equijoin_queries_multiple_regions.html)**
+-   **[Using Indexes on Equi-Join Queries using Multiple 
Regions](using_indexes_with_equijoin_queries_multiple_regions.html)**
 
     To query across multiple regions, identify all equi-join conditions. Then, 
create as few indexes for the equi-join conditions as you can while still 
joining all regions.
 
--   **[Index Samples](../../developing/query_index/index_samples.html)**
+-   **[Index Samples](index_samples.html)**
 
     This topic provides code samples for creating query indexes.
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_index/query_index_hints.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/query_index/query_index_hints.html.md.erb 
b/geode-docs/developing/query_index/query_index_hints.html.md.erb
index 9911014..e461367 100644
--- a/geode-docs/developing/query_index/query_index_hints.html.md.erb
+++ b/geode-docs/developing/query_index/query_index_hints.html.md.erb
@@ -19,7 +19,7 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-You can use the hint keyword to allow Geode's query engine to prefer certain 
indexes.
+You can use the hint keyword to allow <%=vars.product_name%>'s query engine to 
prefer certain indexes.
 
 In cases where one index is hinted in a query, the query engine filters off 
the hinted index (if possible) and then iterates and filters from the resulting 
values.
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_select/the_select_statement.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/query_select/the_select_statement.html.md.erb 
b/geode-docs/developing/query_select/the_select_statement.html.md.erb
index baaf6c1..d472889 100644
--- a/geode-docs/developing/query_select/the_select_statement.html.md.erb
+++ b/geode-docs/developing/query_select/the_select_statement.html.md.erb
@@ -80,7 +80,7 @@ When a struct is returned, the name of each field in the 
struct is determined fo
 
 ## <a 
id="concept_85AE7D6B1E2941ED8BD2A8310A81753E__section_972EE73A6F3E4427B6A99DB4EDF5860D"
 class="no-quick-link"></a>DISTINCT
 
-Use the DISTINCT keyword if you want to limit the results set to unique rows. 
Note that in the current version of Geode you are no longer required to use the 
DISTINCT keyword in your SELECT statement.
+Use the DISTINCT keyword if you want to limit the results set to unique rows. 
Note that in the current version of <%=vars.product_name%> you are no longer 
required to use the DISTINCT keyword in your SELECT statement.
 
 ``` pre
 SELECT DISTINCT * FROM /exampleRegion
@@ -124,7 +124,7 @@ If you are using ORDER BY queries, you must implement the 
equals and hashCode me
 
 ## <a 
id="concept_85AE7D6B1E2941ED8BD2A8310A81753E__section_69DCAD624E9640028BC86FD67649DEB2"
 class="no-quick-link"></a>Preset Query Functions
 
-Geode provides several built-in functions for evaluating or filtering data 
returned from a query. They include the following:
+<%=vars.product_name%> provides several built-in functions for evaluating or 
filtering data returned from a query. They include the following:
 
 <table>
 <colgroup>

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/query_select/the_where_clause.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/query_select/the_where_clause.html.md.erb 
b/geode-docs/developing/query_select/the_where_clause.html.md.erb
index 834bae9..6fe4498 100644
--- a/geode-docs/developing/query_select/the_where_clause.html.md.erb
+++ b/geode-docs/developing/query_select/the_where_clause.html.md.erb
@@ -162,7 +162,7 @@ SELECT * FROM /exampleRegion portfolio1, 
portfolio1.positions.values positions1,
 
 ## <a id="the_where_clause__section_D91E0B06FFF6431490CC0BFA369425AD" 
class="no-quick-link"></a>LIKE
 
-Geode offers limited support for the LIKE predicate. LIKE can be used to mean 
'equals to'. If you terminate the string with a wildcard ('%'), it behaves like 
'starts with'. You can also place a wildcard (either '%' or '\_') at any other 
position in the comparison string. You can escape the wildcard characters to 
represent the characters themselves.
+<%=vars.product_name%> offers limited support for the LIKE predicate. LIKE can 
be used to mean 'equals to'. If you terminate the string with a wildcard ('%'), 
it behaves like 'starts with'. You can also place a wildcard (either '%' or 
'\_') at any other position in the comparison string. You can escape the 
wildcard characters to represent the characters themselves.
 
 **Note:**
 The '\*' wildcard is not supported in OQL LIKE predicates.
@@ -318,7 +318,7 @@ One problem is that you cannot create indexes on Set or 
List types (collection t
 
 ## <a id="the_where_clause__section_E7206D045BEC4F67A8D2B793922BF213" 
class="no-quick-link"></a>Double.NaN and Float.NaN Comparisons
 
-The comparison behavior of Double.NaN and Float.NaN within Geode queries 
follow the semantics of the JDK methods Float.compareTo and Double.compareTo.
+The comparison behavior of Double.NaN and Float.NaN within 
<%=vars.product_name%> queries follow the semantics of the JDK methods 
Float.compareTo and Double.compareTo.
 
 In summary, the comparisons differ in the following ways from those performed 
by the Java language numerical comparison operators (<, <=, ==, >= >) when 
applied to primitive double [float] values:
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/querying_basics/chapter_overview.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/querying_basics/chapter_overview.html.md.erb 
b/geode-docs/developing/querying_basics/chapter_overview.html.md.erb
index 328cc46..b7291c8 100644
--- a/geode-docs/developing/querying_basics/chapter_overview.html.md.erb
+++ b/geode-docs/developing/querying_basics/chapter_overview.html.md.erb
@@ -27,11 +27,11 @@ Since Geode regions are key-value stores where values can 
range from simple byte
 
     This topic answers some frequently asked questions on querying 
functionality. It provides examples to help you get started with Geode querying.
 
--   **[Basic Querying](../../developing/querying_basics/query_basics.html)**
+-   **[Basic Querying](query_basics.html)**
 
     This section provides a high-level introduction to Geode querying such as 
building a query string and describes query language features.
 
--   **[Advanced 
Querying](../../developing/query_additional/advanced_querying.html)**
+-   **[Advanced Querying](../query_additional/advanced_querying.html)**
 
     This section includes advanced querying topics such as using query 
indexes, using query bind parameters, querying partitioned regions and query 
debugging.
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/querying_basics/query_basics.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/querying_basics/query_basics.html.md.erb 
b/geode-docs/developing/querying_basics/query_basics.html.md.erb
index 4121140..b2928ff 100644
--- a/geode-docs/developing/querying_basics/query_basics.html.md.erb
+++ b/geode-docs/developing/querying_basics/query_basics.html.md.erb
@@ -19,12 +19,12 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-This section provides a high-level introduction to Geode querying such as 
building a query string and describes query language features.
+This section provides a high-level introduction to <%=vars.product_name%> 
querying such as building a query string and describes query language features.
 
 <a id="querying_with_oql__section_828A9660B5014DCAA883A58A45E6B51A"></a>
-Geode provides a SQL-like querying language that allows you to access data 
stored in Geode regions. Since Geode regions are key-value stores where values 
can range from simple byte arrays to complex nested objects, Geode uses a query 
syntax based on OQL (Object Query Language) to query region data. OQL and SQL 
have many syntactical similarities, however they have significant differences. 
For example, while OQL does not offer all of the capabilities of SQL like 
aggregates, OQL does allow you to execute queries on complex object graphs, 
query object attributes and invoke object methods.
+<%=vars.product_name%> provides a SQL-like querying language that allows you 
to access data stored in <%=vars.product_name%> regions. Since 
<%=vars.product_name%> regions are key-value stores where values can range from 
simple byte arrays to complex nested objects, <%=vars.product_name%> uses a 
query syntax based on OQL (Object Query Language) to query region data. OQL and 
SQL have many syntactical similarities, however they have significant 
differences. For example, while OQL does not offer all of the capabilities of 
SQL like aggregates, OQL does allow you to execute queries on complex object 
graphs, query object attributes and invoke object methods.
 
-The syntax of a typical Geode OQL query is:
+The syntax of a typical <%=vars.product_name%> OQL query is:
 
 ``` pre
 [IMPORT package]
@@ -34,24 +34,24 @@ FROM collection1, [collection2, …]
 [ORDER BY order_criteria [desc]]
 ```
 
-Therefore, a simple Geode OQL query resembles the following:
+Therefore, a simple <%=vars.product_name%> OQL query resembles the following:
 
 ``` pre
 SELECT DISTINCT * FROM /exampleRegion WHERE status = ‘active’
 ```
 
-An important characteristic of Geode querying to note is that by default, 
Geode queries on the values of a region and not on keys. To obtain keys from a 
region, you must use the keySet path expression on the queried region. For 
example, `/exampleRegion.keySet`.
+An important characteristic of <%=vars.product_name%> querying to note is that 
by default, <%=vars.product_name%> queries on the values of a region and not on 
keys. To obtain keys from a region, you must use the keySet path expression on 
the queried region. For example, `/exampleRegion.keySet`.
 
-For those new to the Geode querying, see also the [Geode Querying FAQ and 
Examples](../../getting_started/querying_quick_reference.html#reference_D5CE64F5FD6F4A808AEFB748C867189E).
+For those new to the <%=vars.product_name%> querying, see also the 
[<%=vars.product_name%> Querying FAQ and 
Examples](../../getting_started/querying_quick_reference.html#reference_D5CE64F5FD6F4A808AEFB748C867189E).
 
--   **[Advantages of 
OQL](../../developing/querying_basics/oql_compared_to_sql.html)**
+-   **[Advantages of OQL](oql_compared_to_sql.html)**
 
--   **[Writing and Executing a Query in 
Geode](../../developing/querying_basics/running_a_query.html)**
+-   **[Writing and Executing a Query in 
<%=vars.product_name%>](running_a_query.html)**
 
--   **[Building a Query 
String](../../developing/querying_basics/what_is_a_query_string.html)**
+-   **[Building a Query String](what_is_a_query_string.html)**
 
--   **[OQL Syntax and 
Semantics](../../developing/query_additional/query_language_features.html)**
+-   **[OQL Syntax and 
Semantics](../query_additional/query_language_features.html)**
 
--   **[Query Language Restrictions and Unsupported 
Features](../../developing/querying_basics/restrictions_and_unsupported_features.html)**
+-   **[Query Language Restrictions and Unsupported 
Features](restrictions_and_unsupported_features.html)**
 
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/querying_basics/querying_partitioned_regions.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/querying_basics/querying_partitioned_regions.html.md.erb
 
b/geode-docs/developing/querying_basics/querying_partitioned_regions.html.md.erb
index 0105d82..882fb9a 100644
--- 
a/geode-docs/developing/querying_basics/querying_partitioned_regions.html.md.erb
+++ 
b/geode-docs/developing/querying_basics/querying_partitioned_regions.html.md.erb
@@ -19,23 +19,23 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-Geode allows you to manage and store large amounts of data across distributed 
nodes using partitioned regions. The basic unit of storage for a partitioned 
region is a bucket, which resides on a Geode node and contains all the entries 
that map to a single hashcode. In a typical partitioned region query, the 
system distributes the query to all buckets across all nodes, then merges the 
result sets and sends back the query results.
+<%=vars.product_name%> allows you to manage and store large amounts of data 
across distributed nodes using partitioned regions. The basic unit of storage 
for a partitioned region is a bucket, which resides on a <%=vars.product_name%> 
node and contains all the entries that map to a single hashcode. In a typical 
partitioned region query, the system distributes the query to all buckets 
across all nodes, then merges the result sets and sends back the query results.
 
 <a 
id="querying_partitioned_regions__section_4C603563DEDC4303818FB8F894470457"></a>
-The following list summarizes the querying functionality supported by Geode 
for partitioned regions:
+The following list summarizes the querying functionality supported by 
<%=vars.product_name%> for partitioned regions:
 
 -   **Ability to target specific nodes in a query**. If you know that a 
specific bucket contains the data that you want to query, you can use a 
function to ensure that your query only runs the specific node that holds the 
data. This can greatly improve query efficiency. The ability to query data on a 
specific node is only available if you are using functions and if the function 
is executed on one single region. In order to do this, you need to use 
`Query.execute(RegionFunctionContext context)`. See the [Java 
API](/releases/latest/javadoc/org/apache/geode/cache/query/Query.html) and 
[Querying a Partitioned Region on a Single 
Node](../query_additional/query_on_a_single_node.html#concept_30B18A6507534993BD55C2C9E0544A97)
 for more details.
--   **Ability to optimize partitioned region query performance using key 
indexes**. You can improve query performance on data that is partitioned by key 
or a field value by creating a key index and then executing the query using use 
`Query.execute(RegionFunctionContext                         context)` with the 
key or field value used as filter. See the [Java 
API](/releases/latest/javadoc/org/apache/geode/cache/query/Query.html) and 
[Optimizing Queries on Data Partitioned by a Key or Field 
Value](../query_additional/partitioned_region_key_or_field_value.html#concept_3010014DFBC9479783B2B45982014454)
 for more details.
+-   **Ability to optimize partitioned region query performance using key 
indexes**. You can improve query performance on data that is partitioned by key 
or a field value by creating a key index and then executing the query using use 
`Query.execute(RegionFunctionContext context)` with the key or field value used 
as filter. See the [Java 
API](/releases/latest/javadoc/org/apache/geode/cache/query/Query.html) and 
[Optimizing Queries on Data Partitioned by a Key or Field 
Value](../query_additional/partitioned_region_key_or_field_value.html#concept_3010014DFBC9479783B2B45982014454)
 for more details.
 -   **Ability to perform equi-join queries between partitioned regions and 
between partitioned regions and replicated regions**. Join queries between 
partitioned region and between partitioned regions and replicated regions are 
supported through the function service. In order to perform equi-join 
operations on partitioned regions or partitioned regions and replicated 
regions, the partitioned regions must be colocated, and you need to use the 
need to use `Query.execute(RegionFunctionContext                         
context)`. See the [Java 
API](/releases/latest/javadoc/org/apache/geode/cache/query/Query.html) and 
[Performing an Equi-Join Query on Partitioned 
Regions](../partitioned_regions/join_query_partitioned_regions.html#concept_B930D276F49541F282A2CFE639F107DD)
 for more details.
 
--   **[Using ORDER BY on Partitioned 
Regions](../../developing/query_additional/order_by_on_partitioned_regions.html)**
+-   **[Using ORDER BY on Partitioned 
Regions](../query_additional/order_by_on_partitioned_regions.html)**
 
--   **[Querying a Partitioned Region on a Single 
Node](../../developing/query_additional/query_on_a_single_node.html)**
+-   **[Querying a Partitioned Region on a Single 
Node](../query_additional/query_on_a_single_node.html)**
 
--   **[Optimizing Queries on Data Partitioned by a Key or Field 
Value](../../developing/query_additional/partitioned_region_key_or_field_value.html)**
+-   **[Optimizing Queries on Data Partitioned by a Key or Field 
Value](../query_additional/partitioned_region_key_or_field_value.html)**
 
--   **[Performing an Equi-Join Query on Partitioned 
Regions](../../developing/partitioned_regions/join_query_partitioned_regions.html)**
+-   **[Performing an Equi-Join Query on Partitioned 
Regions](../partitioned_regions/join_query_partitioned_regions.html)**
 
--   **[Partitioned Region Query 
Restrictions](../../developing/query_additional/partitioned_region_query_restrictions.html)**
+-   **[Partitioned Region Query 
Restrictions](../query_additional/partitioned_region_query_restrictions.html)**
 
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/querying_basics/reserved_words.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/querying_basics/reserved_words.html.md.erb 
b/geode-docs/developing/querying_basics/reserved_words.html.md.erb
index 7a23f91..67829b9 100644
--- a/geode-docs/developing/querying_basics/reserved_words.html.md.erb
+++ b/geode-docs/developing/querying_basics/reserved_words.html.md.erb
@@ -21,7 +21,7 @@ limitations under the License.
 
 ## <a 
id="concept_4F288B1F9579422FA481FBE2C3ADD007__section_3415163C3EFB46A6BE873E2606C9DE0F"
 class="no-quick-link"></a>Reserved Words
 
-These words are reserved for the query language and may not be used as 
identifiers. The words with asterisk (`*`) after them are not currently used by 
Geode, but are reserved for future implementation.
+These words are reserved for the query language and may not be used as 
identifiers. The words with asterisk (`*`) after them are not currently used by 
<%=vars.product_name%>, but are reserved for future implementation.
 
 <table>
 <colgroup>

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/querying_basics/restrictions_and_unsupported_features.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/querying_basics/restrictions_and_unsupported_features.html.md.erb
 
b/geode-docs/developing/querying_basics/restrictions_and_unsupported_features.html.md.erb
index d315461..0927a04 100644
--- 
a/geode-docs/developing/querying_basics/restrictions_and_unsupported_features.html.md.erb
+++ 
b/geode-docs/developing/querying_basics/restrictions_and_unsupported_features.html.md.erb
@@ -19,7 +19,7 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-At a high level, Geode does not support the following querying features:
+At a high level, <%=vars.product_name%> does not support the following 
querying features:
 
 -   Indexes targeted for joins across more than one region are not supported
 -   Static method invocations. For example, the following query is invalid:

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/querying_basics/running_a_query.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/querying_basics/running_a_query.html.md.erb 
b/geode-docs/developing/querying_basics/running_a_query.html.md.erb
index 6ddb1de..985a231 100644
--- a/geode-docs/developing/querying_basics/running_a_query.html.md.erb
+++ b/geode-docs/developing/querying_basics/running_a_query.html.md.erb
@@ -1,6 +1,4 @@
----
-title:  Writing and Executing a Query in Geode
----
+<% set_title("Writing and Executing a Query in", product_name) %>
 
 <!--
 Licensed to the Apache Software Foundation (ASF) under one or more
@@ -20,7 +18,7 @@ limitations under the License.
 -->
 
 <a id="running_a_querying__section_C285160AF91C4486A39444C3A22D6475"></a>
-The Geode QueryService provides methods to create the Query object. You can 
then use the Query object to perform query-related operations.
+The <%=vars.product_name%> QueryService provides methods to create the Query 
object. You can then use the Query object to perform query-related operations.
 
 The QueryService instance you should use depends on whether you are querying 
the local cache of an application or if you want your application to query the 
server cache.
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/querying_basics/supported_character_sets.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/querying_basics/supported_character_sets.html.md.erb 
b/geode-docs/developing/querying_basics/supported_character_sets.html.md.erb
index 50b9c87..e5db399 100644
--- a/geode-docs/developing/querying_basics/supported_character_sets.html.md.erb
+++ b/geode-docs/developing/querying_basics/supported_character_sets.html.md.erb
@@ -19,6 +19,6 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-Geode query language supports the full ASCII and Unicode character sets.
+<%=vars.product_name%> query language supports the full ASCII and Unicode 
character sets.
 
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/querying_basics/what_is_a_query_string.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/querying_basics/what_is_a_query_string.html.md.erb 
b/geode-docs/developing/querying_basics/what_is_a_query_string.html.md.erb
index eb79645..f12729b 100644
--- a/geode-docs/developing/querying_basics/what_is_a_query_string.html.md.erb
+++ b/geode-docs/developing/querying_basics/what_is_a_query_string.html.md.erb
@@ -37,14 +37,14 @@ A query string follows the rules specified by the query 
language and grammar. It
 
 The components listed above can all be part of the query string, but none of 
the components are required. At a minimum, a query string contains an 
expression that can be evaluated against specified data.
 
-The following sections provide guidelines for the query language building 
blocks that are used when writing typical Geode queries.
+The following sections provide guidelines for the query language building 
blocks that are used when writing typical <%=vars.product_name%> queries.
 
--   **[IMPORT 
Statement](../../developing/query_select/the_import_statement.html)**
+-   **[IMPORT Statement](../query_select/the_import_statement.html)**
 
--   **[FROM Clause](../../developing/query_select/the_from_clause.html)**
+-   **[FROM Clause](../query_select/the_from_clause.html)**
 
--   **[WHERE Clause](../../developing/query_select/the_where_clause.html)**
+-   **[WHERE Clause](../query_select/the_where_clause.html)**
 
--   **[SELECT 
Statement](../../developing/query_select/the_select_statement.html)**
+-   **[SELECT Statement](../query_select/the_select_statement.html)**
 
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/region_options/chapter_overview.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/region_options/chapter_overview.html.md.erb 
b/geode-docs/developing/region_options/chapter_overview.html.md.erb
index e48ac79..be1ac36 100644
--- a/geode-docs/developing/region_options/chapter_overview.html.md.erb
+++ b/geode-docs/developing/region_options/chapter_overview.html.md.erb
@@ -19,21 +19,21 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-The Apache Geode data storage and distribution models put your data in the 
right place at the right time. You should understand all the options for data 
storage in Geode before you configure your data regions.
+The <%=vars.product_name_long%> data storage and distribution models put your 
data in the right place at the right time. You should understand all the 
options for data storage in <%=vars.product_name%> before you configure your 
data regions.
 
--   **[Storage and Distribution 
Options](../../developing/region_options/storage_distribution_options.html)**
+-   **[Storage and Distribution Options](storage_distribution_options.html)**
 
-    Geode provides several models for data storage and distribution, including 
partitioned or replicated regions as well as distributed or non-distributed 
regions (local cache storage).
+    <%=vars.product_name%> provides several models for data storage and 
distribution, including partitioned or replicated regions as well as 
distributed or non-distributed regions (local cache storage).
 
--   **[Region Types](../../developing/region_options/region_types.html)**
+-   **[Region Types](region_types.html)**
 
     Region types define region behavior within a single distributed system. 
You have various options for region data storage and distribution.
 
--   **[Region Data Stores and Data 
Accessors](../../developing/region_options/data_hosts_and_accessors.html)**
+-   **[Region Data Stores and Data Accessors](data_hosts_and_accessors.html)**
 
     Understand the difference between members that store data for a region and 
members that act only as data accessors to the region.
 
--   **[Creating Regions 
Dynamically](../../developing/region_options/dynamic_region_creation.html)**
+-   **[Creating Regions Dynamically](dynamic_region_creation.html)**
 
     You can dynamically create regions in your application code and 
automatically instantiate them on members of a distributed system.
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/region_options/dynamic_region_creation.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/region_options/dynamic_region_creation.html.md.erb 
b/geode-docs/developing/region_options/dynamic_region_creation.html.md.erb
index 2652e3d..c26422f 100644
--- a/geode-docs/developing/region_options/dynamic_region_creation.html.md.erb
+++ b/geode-docs/developing/region_options/dynamic_region_creation.html.md.erb
@@ -25,7 +25,7 @@ If your application does not require partitioned regions, you 
can use the <span
 
 Due to the number of options involved, most developers use functions to create 
regions dynamically in their applications, as described in this topic. Dynamic 
regions can also be created from the `gfsh` command line.
 
-For a complete discussion of using Geode functions, see [Function 
Execution](../function_exec/chapter_overview.html). Functions use the <span 
class="keyword apiname">org.apache.geode.cache.execute.FunctionService</span> 
class.
+For a complete discussion of using <%=vars.product_name%> functions, see 
[Function Execution](../function_exec/chapter_overview.html). Functions use the 
<span class="keyword 
apiname">org.apache.geode.cache.execute.FunctionService</span> class.
 
 For example, the following Java classes define and use a function for dynamic 
region creation:
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/region_options/region_types.html.md.erb
----------------------------------------------------------------------
diff --git a/geode-docs/developing/region_options/region_types.html.md.erb 
b/geode-docs/developing/region_options/region_types.html.md.erb
index 57e565e..e12bb24 100644
--- a/geode-docs/developing/region_options/region_types.html.md.erb
+++ b/geode-docs/developing/region_options/region_types.html.md.erb
@@ -22,7 +22,7 @@ limitations under the License.
 Region types define region behavior within a single distributed system. You 
have various options for region data storage and distribution.
 
 <a id="region_types__section_E3435ED1D0D142538B99FA69A9E449EF"></a>
-Within a Geode distributed system, you can define distributed regions and 
non-distributed regions, and you can define regions whose data is spread across 
the distributed system, and regions whose data is entirely contained in a 
single member.
+Within a <%=vars.product_name%> distributed system, you can define distributed 
regions and non-distributed regions, and you can define regions whose data is 
spread across the distributed system, and regions whose data is entirely 
contained in a single member.
 
 Your choice of region type is governed in part by the type of application you 
are running. In particular, you need to use specific region types for your 
servers and clients for effective communication between the two tiers:
 
@@ -102,8 +102,8 @@ Partitioned regions group your data into buckets, each of 
which is stored on a s
 
 Use partitioning for:
 
--   **Large data sets**. Store data sets that are too large to fit into a 
single member, and all members will see the same logical data set. Partitioned 
regions divide the data into units of storage called buckets that are split 
across the members hosting the partitioned region data, so no member needs to 
host all of the region’s data. Geode provides dynamic redundancy recovery and 
rebalancing of partitioned regions, making them the choice for large-scale data 
containers. More members in the system can accommodate more uniform balancing 
of the data across all host members, allowing system throughput (both gets and 
puts) to scale as new members are added.
--   **High availability**. Partitioned regions allow you configure the number 
of copies of your data that Geode should make. If a member fails, your data 
will be available without interruption from the remaining members. Partitioned 
regions can also be persisted to disk for additional high availability.
+-   **Large data sets**. Store data sets that are too large to fit into a 
single member, and all members will see the same logical data set. Partitioned 
regions divide the data into units of storage called buckets that are split 
across the members hosting the partitioned region data, so no member needs to 
host all of the region’s data. <%=vars.product_name%> provides dynamic 
redundancy recovery and rebalancing of partitioned regions, making them the 
choice for large-scale data containers. More members in the system can 
accommodate more uniform balancing of the data across all host members, 
allowing system throughput (both gets and puts) to scale as new members are 
added.
+-   **High availability**. Partitioned regions allow you configure the number 
of copies of your data that <%=vars.product_name%> should make. If a member 
fails, your data will be available without interruption from the remaining 
members. Partitioned regions can also be persisted to disk for additional high 
availability.
 -   **Scalability**. Partitioned regions can scale to large amounts of data 
because the data is divided between the members available to host the region. 
Increase your data capacity dynamically by simply adding new members. 
Partitioned regions also allow you to scale your processing capacity. Because 
your entries are spread out across the members hosting the region, reads and 
writes to those entries are also spread out across those members.
 -   **Good write performance**. You can configure the number of copies of your 
data. The amount of data transmitted per write does not increase with the 
number of members. By contrast, with replicated regions, each write must be 
sent to every member that has the region replicated, so the amount of data 
transmitted per write increases with the number of members.
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/region_options/storage_distribution_options.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/region_options/storage_distribution_options.html.md.erb 
b/geode-docs/developing/region_options/storage_distribution_options.html.md.erb
index f30135e..6cbafc6 100644
--- 
a/geode-docs/developing/region_options/storage_distribution_options.html.md.erb
+++ 
b/geode-docs/developing/region_options/storage_distribution_options.html.md.erb
@@ -19,11 +19,11 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-Geode provides several models for data storage and distribution, including 
partitioned or replicated regions as well as distributed or non-distributed 
regions (local cache storage).
+<%=vars.product_name%> provides several models for data storage and 
distribution, including partitioned or replicated regions as well as 
distributed or non-distributed regions (local cache storage).
 
 ## <a 
id="concept_B18B7754E7C7485BA6D66F2DDB7A11FB__section_787D674A64244871AE49CBB58475088E"
 class="no-quick-link"></a>Peer-to-Peer Region Storage and Distribution
 
-At its most general, data management means having current data available when 
and where your applications need it. In a properly configured Geode 
installation, you store your data in your local members and Geode automatically 
distributes it to the other members that need it according to your cache 
configuration settings. You may be storing very large data objects that require 
special consideration, or you may have a high volume of data requiring careful 
configuration to safeguard your application's performance or memory use. You 
may need to be able to explicitly lock some data during particular operations. 
Most data management features are available as configuration options, which you 
can specify either using the `gfsh` cluster configuration service, `cache.xml` 
file or the API. Once configured, Geode manages the data automatically. For 
example, this is how you manage data distribution, disk storage, data 
expiration activities, and data partitioning. A few features are managed at ru
 n-time through the API.
+At its most general, data management means having current data available when 
and where your applications need it. In a properly configured 
<%=vars.product_name%> installation, you store your data in your local members 
and <%=vars.product_name%> automatically distributes it to the other members 
that need it according to your cache configuration settings. You may be storing 
very large data objects that require special consideration, or you may have a 
high volume of data requiring careful configuration to safeguard your 
application's performance or memory use. You may need to be able to explicitly 
lock some data during particular operations. Most data management features are 
available as configuration options, which you can specify either using the 
`gfsh` cluster configuration service, `cache.xml` file or the API. Once 
configured, <%=vars.product_name%> manages the data automatically. For example, 
this is how you manage data distribution, disk storage, data expiration 
activities, and 
 data partitioning. A few features are managed at run-time through the API.
 
 At the architectural level, data distribution runs between peers in a single 
system and between clients and servers.
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/storing_data_on_disk/chapter_overview.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/storing_data_on_disk/chapter_overview.html.md.erb 
b/geode-docs/developing/storing_data_on_disk/chapter_overview.html.md.erb
index 002fb53..d41b009 100644
--- a/geode-docs/developing/storing_data_on_disk/chapter_overview.html.md.erb
+++ b/geode-docs/developing/storing_data_on_disk/chapter_overview.html.md.erb
@@ -24,17 +24,17 @@ You can persist data on disk for backup purposes and 
overflow it to disk to free
 **Note:**
 This supplements the general steps for managing data regions provided in 
[Basic Configuration and Programming](../../basic_config/book_intro.html).
 
-All disk storage uses Apache Geode[Disk 
Storage](../../managing/disk_storage/chapter_overview.html).
+All disk storage uses <%=vars.product_name_long%> [Disk 
Storage](../../managing/disk_storage/chapter_overview.html).
 
--   **[How Persistence and Overflow 
Work](../../developing/storing_data_on_disk/how_persist_overflow_work.html)**
+-   **[How Persistence and Overflow Work](how_persist_overflow_work.html)**
 
-    To use Geode persistence and overflow, you should understand how they work 
with your data.
+    To use <%=vars.product_name%> persistence and overflow, you should 
understand how they work with your data.
 
--   **[Configure Region Persistence and 
Overflow](../../developing/storing_data_on_disk/storing_data_on_disk.html)**
+-   **[Configure Region Persistence and Overflow](storing_data_on_disk.html)**
 
     Plan persistence and overflow for your data regions and configure them 
accordingly.
 
--   **[Overflow Configuration 
Examples](../../developing/storing_data_on_disk/overflow_config_examples.html)**
+-   **[Overflow Configuration Examples](overflow_config_examples.html)**
 
     The `cache.xml` examples show configuration of region and server 
subscription queue overflows.
 

http://git-wip-us.apache.org/repos/asf/geode/blob/ed9a8fd4/geode-docs/developing/storing_data_on_disk/how_persist_overflow_work.html.md.erb
----------------------------------------------------------------------
diff --git 
a/geode-docs/developing/storing_data_on_disk/how_persist_overflow_work.html.md.erb
 
b/geode-docs/developing/storing_data_on_disk/how_persist_overflow_work.html.md.erb
index 1a1cc10..89f63a3 100644
--- 
a/geode-docs/developing/storing_data_on_disk/how_persist_overflow_work.html.md.erb
+++ 
b/geode-docs/developing/storing_data_on_disk/how_persist_overflow_work.html.md.erb
@@ -19,14 +19,14 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 -->
 
-To use Geode persistence and overflow, you should understand how they work 
with your data.
+To use <%=vars.product_name%> persistence and overflow, you should understand 
how they work with your data.
 
 <a id="how_persist_overflow_work__section_jzl_wwb_pr"></a>
-Geode persists and overflows several types of data. You can persist or 
overflow the application data in your regions. In addition, Geode persists and 
overflows messaging queues between distributed systems, to manage memory 
consumption and provide high availability.
+<%=vars.product_name%> persists and overflows several types of data. You can 
persist or overflow the application data in your regions. In addition, 
<%=vars.product_name%> persists and overflows messaging queues between 
distributed systems, to manage memory consumption and provide high availability.
 
 Persistent data outlives the member where the region resides and can be used 
to initialize the region at creation. Overflow acts only as an extension of the 
region in memory.
 
-The data is written to disk according to the configuration of Geode disk 
stores. For any disk option, you can specify the name of the disk store to use 
or use the Geode default disk store. See [Disk 
Storage](../../managing/disk_storage/chapter_overview.html).
+The data is written to disk according to the configuration of 
<%=vars.product_name%> disk stores. For any disk option, you can specify the 
name of the disk store to use or use the <%=vars.product_name%> default disk 
store. See [Disk Storage](../../managing/disk_storage/chapter_overview.html).
 
 ## <a id="how_persist_overflow_work__section_78F2D1820B6C48859A0E5411CE360105" 
class="no-quick-link"></a>How Data Is Persisted and Overflowed
 

Reply via email to