google
diff --git a/‎docs/data-definition-language.md‎
Lines changed: 63 additions & 1 deletion b/‎docs/data-definition-language.md‎
Lines changed: 63 additions & 1 deletion
diff --git a/‎docs/functions-and-operators.md‎
Lines changed: 281 additions & 0 deletions b/‎docs/functions-and-operators.md‎
Lines changed: 281 additions & 0 deletions
diff --git a/‎docs/graph-gql-functions.md‎
Lines changed: 7 additions & 4 deletions b/‎docs/graph-gql-functions.md‎
Lines changed: 7 additions & 4 deletions
@@ -886,7 +886,69 @@ Documentation is pending for this feature.
 
 ## `CREATE PROCEDURE`
 
-Documentation is pending for this feature.
+<pre>
+CREATE
+  [OR REPLACE]
+  [{ TEMP[ORARY] | PUBLIC | PRIVATE }]
+  PROCEDURE
+  [IF NOT EXISTS]
+  procedure_name
+  ( [ <span class="var">parameter_definition</span> [, ...] ] )
+  [OPTIONS (key=value, ...)]
+  BEGIN
+    <span class="var">sql_statement_list</span>
+  END;
+
+<span class="var">parameter_definition:</span>
+  [ <span class="var">mode</span> ] parameter_name type
+
+<span class="var">mode:</span>
+  { IN | OUT | INOUT }
+</pre>
+
+**Description**
+
+The `CREATE PROCEDURE` statement creates a procedure. A procedure is a reusable
+block of SQL statements that can be invoked by name from other queries, and
+supports arguments.
+
+**Optional Clauses**
+
++   `OR REPLACE`: Replaces any procedure with the same name if it exists. Can't
+    appear with `IF NOT EXISTS`.
++   `TEMP | TEMPORARY`: Creates a temporary procedure. The lifetime of the
+    procedure is system specific.
++   `PUBLIC`: If the procedure is declared in a module, `PUBLIC` specifies that
+    it's available outside of the module.
++   `PRIVATE`: If the procedure is declared in a module, `PRIVATE` specifies
+    that it's only available inside of the module (default).
++   `IF NOT EXISTS`: If any procedure exists with the same name, the `CREATE`
+    statement has no effect. Can't appear with `OR REPLACE`.
++   `parameter_definition`: Defines a parameter for the procedure.
+    +   `mode`: The mode of the parameter. Can be `IN`, `OUT`, or `INOUT`.
+        +   `IN`: The parameter is an input parameter.
+        +   `OUT`: The parameter is an output parameter.
+        +   `INOUT`: The parameter is both an input and an output parameter.
+    +   `parameter_name`: The name of the parameter.
+    +   `type`: The ZetaSQL data type of the parameter.
+    +   `DEFAULT default_value`: The default value for the parameter.
++   `OPTIONS`: If you have schema options, you can add them when you create the
+    procedure. These options are system specific and follow the ZetaSQL[`HINT`
+    syntax][hints].
++   `BEGIN ... END`: The block of SQL statements that make up the procedure.
+
+**Example**
+
+```sql
+CREATE PROCEDURE my_procedure(IN x INT64, OUT y STRING)
+BEGIN
+  IF x > 0 THEN
+    SET y = 'positive';
+  ELSE
+    SET y = 'non-positive';
+  END IF;
+END;
+```
 
 ## `CREATE ROW POLICY`
 
 
@@ -41495,6 +41495,14 @@ canonical equivalence.
   </td>
 </tr>
 
+<tr>
+  <td><a href="#regexp_extract_groups"><code>REGEXP_EXTRACT_GROUPS</code></a>
+</td>
+  <td>
+    Produces substrings that match multiple capturing groups in a regular expression.
+  </td>
+</tr>
+
 <tr>
   <td><a href="#regexp_extract_all"><code>REGEXP_EXTRACT_ALL</code></a>
 </td>
@@ -44078,6 +44086,9 @@ If the regular expression contains a capturing group (`(...)`), and there is a
 match for that capturing group, that match is returned. If there
 are multiple matches for a capturing group, the first match is returned.
 
+To extract matches for multiple capturing groups in a single call, use
+[`REGEXP_EXTRACT_GROUPS`][regexp-extract-groups].
+
 If `position` is specified, the search starts at this
 position in `value`, otherwise it starts at the beginning of `value`. The
 `position` must be a positive integer and can't be 0. If `position` is greater
@@ -44173,6 +44184,276 @@ position, occurrence) AS regexp_value FROM example;
 
 [string-link-to-re2]: https://github.com/google/re2/wiki/Syntax
 
+[regexp-extract-groups]: #regexp_extract_groups
+
+### `REGEXP_EXTRACT_GROUPS`
+
+```zetasql
+REGEXP_EXTRACT_GROUPS(value, regexp)
+```
+
+**Description**
+
+Returns a `STRUCT` where each field contains a substring from `value` that
+matches a capturing group in the [re2 regular expression][string-link-to-re2],
+`regexp`. The function returns the substrings from the first place in `value`
+where the *entire* `regexp` pattern matches.
+
+**Details**
+
+This function is similar to [`REGEXP_EXTRACT`][regexp-extract], but it returns a
+`STRUCT` with a field for each capturing group in the `regexp`.
+
+The `regexp` must contain at least one capturing group. The fields in the
+returned `STRUCT` correspond to these capturing groups:
+
++   If a capturing group is named (for example, `(?<name>...)` or `(?P<name>...)`),
+    the corresponding `STRUCT` field will have that name. Both syntaxes are
+    equivalent.
++   If a capturing group is unnamed, the corresponding `STRUCT` field is
+    anonymous. These fields can be accessed by their 0-based position in the
+    `STRUCT`.
++   The order of fields in the `STRUCT` matches the order of the capturing
+    groups in `regexp` from left to right.
+
+Returns `NULL` if `value` is `NULL` or if the overall `regexp` pattern doesn't
+match at all. If a specific capturing group doesn't match (for example, if it's
+part of an alternation or is optional), the corresponding `STRUCT` field is
+`NULL`.
+
+Returns an error if:
+
++ The `regexp` is invalid.
++ The `regexp` is not a string literal.
++ The `regexp` has no capturing groups.
++ A capturing group name is not a valid `STRUCT` field name (for example, starts
+  with a digit or contains spaces). Valid names consist of letters, numbers,
+  and underscores, and must start with a letter or underscore.
++ The same capturing group name is used more than once (case-insensitive).
+
+**Return type**
+
+`STRUCT<...>`
+
+The fields of the `STRUCT` are generally `STRING` (or `BYTES` if the inputs are
+`BYTES`). However, fields can be [auto-casted](#auto_casting) to other types.
+
+**Examples**
+
+Extract unnamed groups:
+
+```zetasql
+SELECT REGEXP_EXTRACT_GROUPS('abc123xyz', r'([a-z]+)([0-9]+)([a-z]+)') AS result
+
+/*---------------------------------*
+ | result                          |
+ +---------------------------------+
+ | {abc, 123, xyz}                 |
+ *---------------------------------*/
+```
+
+Extract named groups:
+
+```zetasql
+SELECT REGEXP_EXTRACT_GROUPS('2025-09-10', r'(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})') AS result
+
+/*----------------------------------------------*
+ | result                                       |
+ +----------------------------------------------+
+ | {2025 year, 09 month, 10 day}                |
+ *----------------------------------------------*/
+```
+
+**Expand STRUCT fields into columns**
+
+Because `REGEXP_EXTRACT_GROUPS` returns a `STRUCT`, you can use the `.*` operator
+in the `SELECT` list to expand the fields of the `STRUCT` into separate columns.
+Expanding `STRUCT` fields into columns is particularly useful when all capturing
+groups are named.
+
+```zetasql
+SELECT REGEXP_EXTRACT_GROUPS('PROD-WIDGET-1234', r'(?<env>\w+)-(?<product>\w+)-(?<id>\d+)').*
+
+/*-------+-----------+------*
+ | env   | product   | id   |
+ +-------+-----------+------+
+ | PROD  | WIDGET    | 1234 |
+ *-------+-----------+------*/
+```
+
+Mix of named and unnamed groups:
+
+```zetasql
+SELECT REGEXP_EXTRACT_GROUPS('id:123', r'(?<key>[a-z]+):([0-9]+)') AS result
+
+/*-----------------------*
+ | result                |
+ +-----------------------+
+ | {id key, 123}         |
+ *-----------------------*/
+```
+
+No match returns `NULL`:
+
+```zetasql
+SELECT REGEXP_EXTRACT_GROUPS('abc', r'(\d+)') AS result
+
+/*--------*
+ | result |
+ +--------+
+ | NULL   |
+ *--------*/
+```
+
+Optional groups and empty matches:
+
+```zetasql
+WITH inputs AS (
+  SELECT 'id:123:extra' AS t UNION ALL
+  SELECT 'id:123:' AS t UNION ALL
+  SELECT 'id:123' AS t
+)
+SELECT
+  t,
+  REGEXP_EXTRACT_GROUPS(t, r'(?<key>\w+):(?<val>\w+)(?::(?<opt>\w*))?') AS result
+FROM inputs;
+
+/*-----------------+--------------------------------------*
+ | t               | result                               |
+ +-----------------+--------------------------------------+
+ | id:123:extra    | {id key, 123 val, extra opt}         |
+ | id:123:         | {id key, 123 val,  opt}              |
+ | id:123          | {id key, 123 val, NULL opt}          |
+ *-----------------+--------------------------------------*/
+```
+
+Note that in the second row, the optional group `opt` matches an empty string,
+which is different from the third row where the group doesn't match at all and
+results in `NULL`.
+
+Nested groups:
+
+```zetasql
+SELECT REGEXP_EXTRACT_GROUPS('a=b=c', r'(\w+)=((\w+)=\w+)') AS result
+
+/*-----------------------*
+ | result                |
+ +-----------------------+
+ | {a, b=c, b}           |
+ *-----------------------*/
+```
+
+Alternation with different groups:
+
+```zetasql
+WITH inputs AS (
+  SELECT 'config_id=123' AS t UNION ALL
+  SELECT 'option_name=ABC' AS t
+)
+SELECT
+  t,
+  REGEXP_EXTRACT_GROUPS(t, r'config_id=(?<id>\d+)|option_name=(?<name>\w+)') AS result
+FROM inputs;
+
+/*-----------------+--------------------------*
+ | t               | result                   |
+ +-----------------+--------------------------+
+ | config_id=123   | {123 id, NULL name}      |
+ | option_name=ABC | {NULL id, ABC name}      |
+ *-----------------+--------------------------*/
+```
+
+The `STRUCT` result contains fields for all named capturing groups across all
+alternatives in the regular expression. In each row, only the fields
+corresponding to the alternative that matched are populated. Other fields are
+`NULL`.
+
+##### Auto-casting 
+<a id="auto_casting"></a>
+
+You can automatically cast the captured substring to a specific type by
+suffixing the capturing group name with a double underscore (`__`) followed by
+the type name.
+
+Any type that can be cast from `STRING` (or `BYTES` for the `BYTES` version
+of the function) is supported. Type names are case-insensitive.
+
+The field name in the resulting `STRUCT` will have the `__TYPE` suffix removed.
+
+If the captured substring can't be cast to the specified type, an error is
+returned. This includes casting an empty string to a numeric or boolean type.
+If the captured substring is `NULL` (due to an optional group not matching), the
+cast result is also `NULL`.
+
+**Examples of auto-casting**
+
+```zetasql
+SELECT REGEXP_EXTRACT_GROUPS('val=0x1a', r'val=(?<val__INT64>0x[0-9a-fA-F]+)') AS result
+
+/*-------------*
+ | result      |
+ +-------------+
+ | {26 val}    |
+ *-------------*/
+```
+
+Auto-casted values in expressions with Pipe syntax:
+
+```zetasql
+FROM UNNEST(['02:30:10', '01:02:03']) AS time_str
+|> EXTEND REGEXP_EXTRACT_GROUPS(time_str, r'(?<h__INT64>\d{2}):(?<m__INT64>\d{2}):(?<s__INT64>\d{2})').*
+|> SELECT time_str, h * 3600 + m * 60 + s AS total_seconds
+
+/*----------+---------------*
+ | time_str | total_seconds |
+ +----------+---------------+
+ | 02:30:10 | 9010          |
+ | 01:02:03 | 3723          |
+ *----------+---------------*/
+```
+
+Expand auto-casted fields into columns:
+
+```zetasql
+SELECT REGEXP_EXTRACT_GROUPS('2025-09-10', r'(?<year__INT64>\d{4})-(?<month__INT64>\d{2})-(?<day__INT64>\d{2})').*
+
+/*--------+---------+-------*
+ | year   | month   | day   |
+ +--------+---------+-------+
+ | 2025   | 9       | 10    |
+ *--------+---------+-------*/
+```
+
+Cast failure:
+
+```zetasql {.bad}
+-- Error: Bad INT64 value
+SELECT REGEXP_EXTRACT_GROUPS('ID: ABC', r'ID: (?<item_id__INT64>\w+)')
+```
+
+Cast failure with empty string:
+
+```zetasql {.bad}
+-- Error: Bad INT64 value
+SELECT REGEXP_EXTRACT_GROUPS('ID: ', r'ID: (?<item_id__INT64>\d*)')
+```
+
+Workaround for empty string cast failure by making the group optional:
+
+```zetasql
+SELECT REGEXP_EXTRACT_GROUPS('ID: ', r'ID: (?<item_id__INT64>\d+)?') AS result
+
+/*-----------------*
+ | result          |
+ +-----------------+
+ | {NULL item_id}  |
+ *-----------------*/
+```
+
+[string-link-to-re2]: https://github.com/google/re2/wiki/Syntax
+
+[regexp-extract]: #regexp_extract
+
 ### `REGEXP_EXTRACT_ALL`
 
 ```zetasql
 
@@ -967,10 +967,13 @@ RETURN src.id as src_id, num_transfers, unique_amount_transfers, dst.id AS desti
  +---------------------------------------------------------------------------*/
 ```
 
-In the following query, the `SUM` function takes a group variable called
-`e` that represents an array of transfers, and then sums the amount
-for each transfer. Note that horizontal aggregation isn't allowed in the
-`RETURN` statement: that `ARRAY_AGG` is an aggregate over the result set.
+In the following query, the `SUM` function takes a group variable called `e`
+that represents an array of transfers, and then sums the amount for each
+transfer. Horizontal aggregation isn't allowed in the `RETURN`
+statement. `ARRAY_AGG` is a vertical aggregate over the result set, which is
+grouped implicitly by the non-aggregated columns
+(`source_account_id`, `destination_account_id`). `ARRAY_AGG` produces one row
+for each distinct destination account.
 
 ```zetasql
 GRAPH FinGraph