Merge 295fe153ad into 44e626a086

Hello, I've added a small blockquote below the description to indicate that this method of accessing an indefinite number of function arguments has been superseded by the use of the spread operator via rest parameters for ES6+ compatibility.

README.md

@@ -10,7 +10,7 @@ pairing with smart people at Hashrocket.
 
 For a steady stream of TILs, [sign up for my newsletter](https://crafty-builder-6996.ck.page/e169c61186).
 
-_1430 TILs and counting..._
+_1431 TILs and counting..._
 
 ---
 
@@ -734,6 +734,7 @@ _1430 TILs and counting..._
 - [Generate Series Of Numbers](postgres/generate-series-of-numbers.md)
 - [Generating UUIDs With pgcrypto](postgres/generating-uuids-with-pgcrypto.md)
 - [Get A Quick Approximate Count Of A Table](postgres/get-a-quick-approximate-count-of-a-table.md)
+- [Get Row Count For Most Recent Query](postgres/get-row-count-for-most-recent-query.md)
 - [Get The Size On Disk of An Index](postgres/get-the-size-on-disk-of-an-index.md)
 - [Get The Size Of A Database](postgres/get-the-size-of-a-database.md)
 - [Get The Size Of A Table](postgres/get-the-size-of-a-table.md)

javascript/accessing-arguments-to-a-function.md

@@ -5,6 +5,8 @@ an array-like object with all of the arguments to the function. Even if not
 all of the arguments are referenced in the function signature, they can
 still be accessed via the `arguments` object.
 
+> For ES6+ compatibility, the `spread` operator used via [rest parameters](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters) is preferred over the `arugments` object when accessing an abritrary number of function arguments.
+
 ```javascript
 function argTest(one) {
   console.log(one);

postgres/get-row-count-for-most-recent-query.md

@@ -0,0 +1,65 @@
+# Get Row Count For Most Recent Query
+
+Anytime you execute a query in `psql`, there is a _row count_ associated with
+that query. This is most naturally understood with a `select` query where a
+discreet number of rows are returned. We typically see the row count (e.g. `(19
+rows)`) right below the result set.
+
+You can always reference the row count of the most recent query with [the
+`:ROW_COUNT`
+variable](https://www.postgresql.org/docs/current/app-psql.html#APP-PSQL-VARIABLES-ROW-COUNT).
+Here we use `\echo` to print it out.
+
+```sql
+> select generate_series(2,20);
+ generate_series
+-----------------
+               2
+               3
+               4
+               5
+               6
+               7
+               8
+               9
+              10
+              11
+              12
+              13
+              14
+              15
+              16
+              17
+              18
+              19
+              20
+(19 rows)
+
+Time: 12.338 ms
+> \echo :ROW_COUNT
+19
+```
+
+For some queries, like one that induces a pager (e.g. `less`) to be used,
+you'll lose track of the row count once the pager closes. This is where being
+able to reference the row count without rerunning the query is most useful.
+
+```sql
+> select generate_series(2,2000);
+Time: 9.815 ms
+> \echo :ROW_COUNT
+1999
+```
+
+Notice, we can also get a row count from other kinds of queries like this
+`insert` statement.
+
+```sql
+> insert into users (id) values (50001), (50002), (50003);
+INSERT 0 3
+Time: 2.804 ms
+> \echo :ROW_COUNT
+3
+```
+
+[source](https://postgresql.verite.pro/blog/2024/05/13/advanced-psql-coproc.html)