Refresh CAGG page

_partials/_caggs-function-support.md

@@ -1,19 +1,19 @@
 
 The following table summarizes the aggregate functions supported in continuous aggregates:
 
-|Function, clause, or feature|TimescaleDB 2.6 and earlier|TimescaleDB 2.7, 2.8, and 2.9|TimescaleDB 2.10 and later|
-|-|-|-|-|
-|Parallelizable aggregate functions|✅|✅|✅|
-|[non-parallelizable SQL aggregates][postgres-parallel-agg]|❌|✅|✅|
-|`ORDER BY`|❌|✅|✅|
-|Ordered-set aggregates|❌|✅|✅|
-|Hypothetical-set aggregates|❌|✅|✅|
-|`DISTINCT` in aggregate functions|❌|✅|✅|
-|`FILTER` in aggregate functions|❌|✅|✅|
-|`FROM` clause supports `JOINS`|❌|❌|✅|
+| Function, clause, or feature                               |TimescaleDB 2.6 and earlier|TimescaleDB 2.7, 2.8, and 2.9|TimescaleDB 2.10 and later|
+|------------------------------------------------------------|-|-|-|
+| Parallelizable aggregate functions                         |✅|✅|✅|
+| [Non-parallelizable SQL aggregates][postgres-parallel-agg] |❌|✅|✅|
+| `ORDER BY`                                                 |❌|✅|✅|
+| Ordered-set aggregates                                     |❌|✅|✅|
+| Hypothetical-set aggregates                                |❌|✅|✅|
+| `DISTINCT` in aggregate functions                          |❌|✅|✅|
+| `FILTER` in aggregate functions                            |❌|✅|✅|
+| `FROM` clause supports `JOINS`                             |❌|❌|✅|
 
 
-DISTINCT works in aggregate functions not in the query definition. For example, for the table:
+DISTINCT works in aggregate functions, not in the query definition. For example, for the table:
 
 ```sql
 CREATE TABLE public.candle(

_partials/_caggs-intro.md

@@ -1,30 +1,26 @@
 import RealTimeAgg from 'versionContent/_partials/_real-time-aggregates.mdx';
 
 In modern applications, data usually grows very quickly. This means that aggregating 
-it into useful summaries can become very slow. Continuous aggregates in $TIMESCALE_DB make
-aggregating data lightning fast, accurate, and easy. 
-
-If you are collecting data very frequently, you might want to aggregate your
-data into minutes or hours instead. For example, if an IoT device takes 
+it into useful summaries can become very slow. If you are collecting data very frequently, you might want to aggregate your
+data into minutes or hours instead. For example, if an IoT device takes
 temperature readings every second, you might want to find the average temperature
 for each hour. Every time you run this query, the database needs to scan the
-entire table and recalculate the average.
+entire table and recalculate the average. $TIMESCALE_DB makes aggregating data lightning fast, accurate, and easy.
+
+![Reduced data calls with $CAGGs](https://assets.timescale.com/docs/images/continuous-aggregate.png)
 
-Continuous aggregates are a kind of hypertable that is refreshed automatically
+Continuous aggregates in $TIMESCALE_DB are a kind of hypertable that is refreshed automatically
 in the background as new data is added, or old data is modified. Changes to your
 dataset are tracked, and the hypertable behind the continuous aggregate is
 automatically updated in the background.
 
-You don't need to manually refresh your continuous aggregates, they are
-continuously and incrementally updated in the background. Continuous aggregates
-also have a much lower maintenance burden than regular $PG materialized
+Continuous aggregates have a much lower maintenance burden than regular $PG materialized
 views, because the whole view is not created from scratch on each refresh. This
 means that you can get on with working your data instead of maintaining your
 database.
 
-
 Because continuous aggregates are based on hypertables, you can query them in exactly the same way as your other tables. This includes continuous aggregates in the rowstore, compressed into the [columnstore][hypercore], 
-or [tiered to object storage][data-tiering]. You can even create [continuous aggregates on top of your continuous aggregates][hierarchical-caggs] - for an even more fine-tuned aggregation. 
+or [tiered to object storage][data-tiering]. You can even create [continuous aggregates on top of your continuous aggregates][hierarchical-caggs], for an even more fine-tuned aggregation. 
 
 [Real-time aggregation][real-time-aggregation] enables you to combine pre-aggregated data from the materialized view with the most recent raw data. This gives you up-to-date results on every query. <RealTimeAgg />
 

getting-started/try-key-features-timescale-products.md

@@ -217,7 +217,7 @@ $CAGG_CAPs are a kind of $HYPERTABLE that is refreshed automatically in
 the background as new data is added, or old data is modified. Changes to your dataset are tracked, 
 and the $HYPERTABLE behind the $CAGG is automatically updated in the background.
 
-![Reduced data calls with $CAGGs](https://assets.timescale.com/docs/images/continuous-aggregate.png )
+![Reduced data calls with $CAGGs](https://assets.timescale.com/docs/images/continuous-aggregate.png)
 
 You create $CAGGs on uncompressed data in high-performance storage. They continue to work 
 on [data in the $COLUMNSTORE][test-drive-enable-compression]

use-timescale/continuous-aggregates/about-continuous-aggregates.md

@@ -52,7 +52,7 @@ JOINS in TimescaleDB must meet the following conditions:
 *   You can use an `INNER`, `LEFT`, and `LATERAL` joins; no other join type is supported.
 *   Joins on the materialized hypertable of a continuous aggregate are not supported.
 *   Hierarchical continuous aggregates can be created on top of a continuous
-    aggregate with a `JOIN` clause, but cannot themselves have a `JOIN` clauses.
+    aggregate with a `JOIN` clause, but cannot themselves have a `JOIN` clause.
 
 ### JOIN examples
 
@@ -141,7 +141,7 @@ See the following `JOIN` examples on continuous aggregates:
     ```
     TimescaleDB v2.16.x and higher.
 
-- `INNER JOIN` between an hypertable and multiple $PG tables:
+- `INNER JOIN` between a hypertable and multiple $PG tables:
 
     ```sql
     CREATE MATERIALIZED VIEW conditions_by_day WITH (timescaledb.continuous) AS
@@ -154,7 +154,7 @@ See the following `JOIN` examples on continuous aggregates:
     ```
    TimescaleDB v2.16.x and higher.
 
-- `LEFT JOIN` between an hypertable and a $PG table:
+- `LEFT JOIN` between a hypertable and a $PG table:
 
     ```sql
     CREATE MATERIALIZED VIEW conditions_by_day WITH (timescaledb.continuous) AS
@@ -166,7 +166,7 @@ See the following `JOIN` examples on continuous aggregates:
     ```
     TimescaleDB v2.16.x and higher.
 
-- `LATERAL JOIN` between an hypertable and a sub-query:
+- `LATERAL JOIN` between a hypertable and a subquery:
 
     ```sql
     CREATE MATERIALIZED VIEW conditions_by_day WITH (timescaledb.continuous) AS