public inbox for [email protected]help / color / mirror / Atom feed
Re: Add macros for ReorderBufferTXN toptxn 4+ messages / 4 participants [nested] [flat]
* Re: Add macros for ReorderBufferTXN toptxn @ 2023-03-16 01:49 Peter Smith <[email protected]> 0 siblings, 1 reply; 4+ messages in thread From: Peter Smith @ 2023-03-16 01:49 UTC (permalink / raw) To: Masahiko Sawada <[email protected]>; +Cc: Amit Kapila <[email protected]>; vignesh C <[email protected]>; PostgreSQL Hackers <[email protected]> On Wed, Mar 15, 2023 at 4:55 PM Masahiko Sawada <[email protected]> wrote: > > Hi, > ... > +1 to the idea. Here are some minor comments: > > @@ -1667,7 +1658,7 @@ ReorderBufferTruncateTXN(ReorderBuffer *rb, > ReorderBufferTXN *txn, bool txn_prep > * about the toplevel xact (we send the XID in all messages), but we never > * stream XIDs of empty subxacts. > */ > - if ((!txn_prepared) && ((!txn->toptxn) || (txn->nentries_mem != 0))) > + if ((!txn_prepared) && (rbtxn_is_toptxn(txn) || (txn->nentries_mem != 0))) > txn->txn_flags |= RBTXN_IS_STREAMED; > > Probably the following comment of the above lines also needs to be updated? > > * The toplevel transaction, identified by (toptxn==NULL), is marked as > * streamed always, > > --- > +/* Is this a top-level transaction? */ > +#define rbtxn_is_toptxn(txn)\ > +(\ > + (txn)->toptxn == NULL\ > +) > + > +/* Is this a subtransaction? */ > +#define rbtxn_is_subtxn(txn)\ > +(\ > + (txn)->toptxn != NULL\ > +) > + > +/* Get the top-level transaction of this (sub)transaction. */ > +#define rbtxn_get_toptxn(txn)\ > +(\ > + rbtxn_is_subtxn(txn) ? (txn)->toptxn : (txn)\ > +) > > We need a whitespace before backslashes. > Thanks for your interest in my patch. PSA v4 which addresses both of your review comments. ------ Kind Regards, Peter Smith. Fujitsu Australia Attachments: [application/octet-stream] v4-0001-Add-macros-for-ReorderBufferTXN-toptxn.patch (7.0K, ../../CAHut+PsDvFvwBiSzB0bCZgMwDUfOD4dackL0ZcTHXtLuewdobA@mail.gmail.com/2-v4-0001-Add-macros-for-ReorderBufferTXN-toptxn.patch) download | inline diff: From 8318ccb4c2cea70280ef1142f76773cf40267427 Mon Sep 17 00:00:00 2001 From: Peter Smith <[email protected]> Date: Thu, 16 Mar 2023 12:00:50 +1100 Subject: [PATCH v4] Add macros for ReorderBufferTXN toptxn. Make toptxn related code more readable by introducing some simple macros. --- contrib/test_decoding/test_decoding.c | 4 +-- src/backend/replication/logical/reorderbuffer.c | 46 ++++++++++--------------- src/backend/replication/pgoutput/pgoutput.c | 6 ++-- src/include/replication/reorderbuffer.h | 18 ++++++++++ 4 files changed, 41 insertions(+), 33 deletions(-) diff --git a/contrib/test_decoding/test_decoding.c b/contrib/test_decoding/test_decoding.c index b7e6048..628c6a2 100644 --- a/contrib/test_decoding/test_decoding.c +++ b/contrib/test_decoding/test_decoding.c @@ -815,11 +815,11 @@ pg_decode_stream_abort(LogicalDecodingContext *ctx, * maintain the output_plugin_private only under the toptxn so if this is * not the toptxn then fetch the toptxn. */ - ReorderBufferTXN *toptxn = txn->toptxn ? txn->toptxn : txn; + ReorderBufferTXN *toptxn = rbtxn_get_toptxn(txn); TestDecodingTxnData *txndata = toptxn->output_plugin_private; bool xact_wrote_changes = txndata->xact_wrote_changes; - if (txn->toptxn == NULL) + if (rbtxn_is_toptxn(txn)) { Assert(txn->output_plugin_private != NULL); pfree(txndata); diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c index 2d17c55..6714258 100644 --- a/src/backend/replication/logical/reorderbuffer.c +++ b/src/backend/replication/logical/reorderbuffer.c @@ -717,10 +717,7 @@ ReorderBufferProcessPartialChange(ReorderBuffer *rb, ReorderBufferTXN *txn, return; /* Get the top transaction. */ - if (txn->toptxn != NULL) - toptxn = txn->toptxn; - else - toptxn = txn; + toptxn = rbtxn_get_toptxn(txn); /* * Indicate a partial change for toast inserts. The change will be @@ -809,13 +806,7 @@ ReorderBufferQueueChange(ReorderBuffer *rb, TransactionId xid, XLogRecPtr lsn, change->action == REORDER_BUFFER_CHANGE_TRUNCATE || change->action == REORDER_BUFFER_CHANGE_MESSAGE) { - ReorderBufferTXN *toptxn; - - /* get the top transaction */ - if (txn->toptxn != NULL) - toptxn = txn->toptxn; - else - toptxn = txn; + ReorderBufferTXN *toptxn = rbtxn_get_toptxn(txn); toptxn->txn_flags |= RBTXN_HAS_STREAMABLE_CHANGE; } @@ -1655,9 +1646,9 @@ ReorderBufferTruncateTXN(ReorderBuffer *rb, ReorderBufferTXN *txn, bool txn_prep /* * Mark the transaction as streamed. * - * The toplevel transaction, identified by (toptxn==NULL), is marked as - * streamed always, even if it does not contain any changes (that is, when - * all the changes are in subtransactions). + * The top-level transaction, is marked as streamed always, even if it does + * not contain any changes (that is, when all the changes are in + * subtransactions). * * For subtransactions, we only mark them as streamed when there are * changes in them. @@ -1667,7 +1658,7 @@ ReorderBufferTruncateTXN(ReorderBuffer *rb, ReorderBufferTXN *txn, bool txn_prep * about the toplevel xact (we send the XID in all messages), but we never * stream XIDs of empty subxacts. */ - if ((!txn_prepared) && ((!txn->toptxn) || (txn->nentries_mem != 0))) + if ((!txn_prepared) && (rbtxn_is_toptxn(txn) || (txn->nentries_mem != 0))) txn->txn_flags |= RBTXN_IS_STREAMED; if (txn_prepared) @@ -3207,10 +3198,7 @@ ReorderBufferChangeMemoryUpdate(ReorderBuffer *rb, * Update the total size in top level as well. This is later used to * compute the decoding stats. */ - if (txn->toptxn != NULL) - toptxn = txn->toptxn; - else - toptxn = txn; + toptxn = rbtxn_get_toptxn(txn); if (addition) { @@ -3295,8 +3283,7 @@ ReorderBufferAddInvalidations(ReorderBuffer *rb, TransactionId xid, * so that we can execute them all together. See comments atop this * function. */ - if (txn->toptxn) - txn = txn->toptxn; + txn = rbtxn_get_toptxn(txn); Assert(nmsgs > 0); @@ -3354,7 +3341,6 @@ ReorderBufferXidSetCatalogChanges(ReorderBuffer *rb, TransactionId xid, XLogRecPtr lsn) { ReorderBufferTXN *txn; - ReorderBufferTXN *toptxn; txn = ReorderBufferTXNByXid(rb, xid, true, NULL, lsn, true); @@ -3370,11 +3356,15 @@ ReorderBufferXidSetCatalogChanges(ReorderBuffer *rb, TransactionId xid, * conveniently check just top-level transaction and decide whether to * build the hash table or not. */ - toptxn = txn->toptxn; - if (toptxn != NULL && !rbtxn_has_catalog_changes(toptxn)) + if (rbtxn_is_subtxn(txn)) { - toptxn->txn_flags |= RBTXN_HAS_CATALOG_CHANGES; - dclist_push_tail(&rb->catchange_txns, &toptxn->catchange_node); + ReorderBufferTXN *toptxn = rbtxn_get_toptxn(txn); + + if (!rbtxn_has_catalog_changes(toptxn)) + { + toptxn->txn_flags |= RBTXN_HAS_CATALOG_CHANGES; + dclist_push_tail(&rb->catchange_txns, &toptxn->catchange_node); + } } } @@ -3619,7 +3609,7 @@ ReorderBufferCheckMemoryLimit(ReorderBuffer *rb) (txn = ReorderBufferLargestStreamableTopTXN(rb)) != NULL) { /* we know there has to be one, because the size is not zero */ - Assert(txn && !txn->toptxn); + Assert(txn && rbtxn_is_toptxn(txn)); Assert(txn->total_size > 0); Assert(rb->size >= txn->total_size); @@ -4007,7 +3997,7 @@ ReorderBufferStreamTXN(ReorderBuffer *rb, ReorderBufferTXN *txn) bool txn_is_streamed; /* We can never reach here for a subtransaction. */ - Assert(txn->toptxn == NULL); + Assert(rbtxn_is_toptxn(txn)); /* * We can't make any assumptions about base snapshot here, similar to what diff --git a/src/backend/replication/pgoutput/pgoutput.c b/src/backend/replication/pgoutput/pgoutput.c index 00a2d73..3a2d2e3 100644 --- a/src/backend/replication/pgoutput/pgoutput.c +++ b/src/backend/replication/pgoutput/pgoutput.c @@ -694,8 +694,8 @@ maybe_send_schema(LogicalDecodingContext *ctx, if (in_streaming) xid = change->txn->xid; - if (change->txn->toptxn) - topxid = change->txn->toptxn->xid; + if (rbtxn_is_subtxn(change->txn)) + topxid = rbtxn_get_toptxn(change->txn)->xid; else topxid = xid; @@ -1879,7 +1879,7 @@ pgoutput_stream_abort(struct LogicalDecodingContext *ctx, Assert(!in_streaming); /* determine the toplevel transaction */ - toptxn = (txn->toptxn) ? txn->toptxn : txn; + toptxn = rbtxn_get_toptxn(txn); Assert(rbtxn_is_streamed(toptxn)); diff --git a/src/include/replication/reorderbuffer.h b/src/include/replication/reorderbuffer.h index 215d149..e37f512 100644 --- a/src/include/replication/reorderbuffer.h +++ b/src/include/replication/reorderbuffer.h @@ -249,6 +249,24 @@ typedef struct ReorderBufferChange ((txn)->txn_flags & RBTXN_SKIPPED_PREPARE) != 0 \ ) +/* Is this a top-level transaction? */ +#define rbtxn_is_toptxn(txn) \ +( \ + (txn)->toptxn == NULL \ +) + +/* Is this a subtransaction? */ +#define rbtxn_is_subtxn(txn) \ +( \ + (txn)->toptxn != NULL \ +) + +/* Get the top-level transaction of this (sub)transaction. */ +#define rbtxn_get_toptxn(txn) \ +( \ + rbtxn_is_subtxn(txn) ? (txn)->toptxn : (txn) \ +) + typedef struct ReorderBufferTXN { /* See above */ -- 1.8.3.1 ^ permalink raw reply [nested|flat] 4+ messages in thread
* Re: Add macros for ReorderBufferTXN toptxn @ 2023-03-16 05:10 Bharath Rupireddy <[email protected]> parent: Peter Smith <[email protected]> 0 siblings, 1 reply; 4+ messages in thread From: Bharath Rupireddy @ 2023-03-16 05:10 UTC (permalink / raw) To: Peter Smith <[email protected]>; +Cc: Masahiko Sawada <[email protected]>; Amit Kapila <[email protected]>; vignesh C <[email protected]>; PostgreSQL Hackers <[email protected]> On Thu, Mar 16, 2023 at 7:20 AM Peter Smith <[email protected]> wrote: > > PSA v4 which addresses both of your review comments. Looks like a reasonable change to me. A nitpick: how about using rbtxn_get_toptxn instead of an explicit variable toptxn for single use? 1. Change ReorderBufferTXN *toptxn = rbtxn_get_toptxn(txn); TestDecodingTxnData *txndata = toptxn->output_plugin_private; To TestDecodingTxnData *txndata = rbtxn_get_toptxn(txn)->output_plugin_private; 2. Change ReorderBufferTXN *toptxn = rbtxn_get_toptxn(txn); toptxn->txn_flags |= RBTXN_HAS_STREAMABLE_CHANGE; To rbtxn_get_toptxn(txn)->txn_flags |= RBTXN_HAS_STREAMABLE_CHANGE; 3. Change /* * Update the total size in top level as well. This is later used to * compute the decoding stats. */ toptxn = rbtxn_get_toptxn(txn); if (addition) { txn->size += sz; rb->size += sz; /* Update the total size in the top transaction. */ toptxn->total_size += sz; } else { Assert((rb->size >= sz) && (txn->size >= sz)); txn->size -= sz; rb->size -= sz; /* Update the total size in the top transaction. */ toptxn->total_size -= sz; } To /* * Update the total size in top level as well. This is later used to * compute the decoding stats. */ if (addition) { txn->size += sz; rb->size += sz; rbtxn_get_toptxn(txn)->total_size += sz; } else { Assert((rb->size >= sz) && (txn->size >= sz)); txn->size -= sz; rb->size -= sz; rbtxn_get_toptxn(txn)->total_size -= sz; } -- Bharath Rupireddy PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com ^ permalink raw reply [nested|flat] 4+ messages in thread
* Re: Add macros for ReorderBufferTXN toptxn @ 2023-03-16 05:20 Amit Kapila <[email protected]> parent: Bharath Rupireddy <[email protected]> 0 siblings, 0 replies; 4+ messages in thread From: Amit Kapila @ 2023-03-16 05:20 UTC (permalink / raw) To: Bharath Rupireddy <[email protected]>; +Cc: Peter Smith <[email protected]>; Masahiko Sawada <[email protected]>; vignesh C <[email protected]>; PostgreSQL Hackers <[email protected]> On Thu, Mar 16, 2023 at 10:40 AM Bharath Rupireddy <[email protected]> wrote: > > On Thu, Mar 16, 2023 at 7:20 AM Peter Smith <[email protected]> wrote: > > > > PSA v4 which addresses both of your review comments. > > Looks like a reasonable change to me. > > A nitpick: how about using rbtxn_get_toptxn instead of an explicit > variable toptxn for single use? > I find all three suggestions are similar. Personally, I think the current code looks better. The v4 patch LGTM and I am planning to commit it unless there are more comments or people find your suggestions as an improvement. -- With Regards, Amit Kapila. ^ permalink raw reply [nested|flat] 4+ messages in thread
* [PATCH v10 5/7] Row pattern recognition patch (docs). @ 2023-10-22 02:22 Tatsuo Ishii <[email protected]> 0 siblings, 0 replies; 4+ messages in thread From: Tatsuo Ishii @ 2023-10-22 02:22 UTC (permalink / raw) --- doc/src/sgml/advanced.sgml | 80 ++++++++++++++++++++++++++++++++++++ doc/src/sgml/func.sgml | 54 ++++++++++++++++++++++++ doc/src/sgml/ref/select.sgml | 38 ++++++++++++++++- 3 files changed, 170 insertions(+), 2 deletions(-) diff --git a/doc/src/sgml/advanced.sgml b/doc/src/sgml/advanced.sgml index 755c9f1485..cf18dd887e 100644 --- a/doc/src/sgml/advanced.sgml +++ b/doc/src/sgml/advanced.sgml @@ -537,6 +537,86 @@ WHERE pos < 3; <literal>rank</literal> less than 3. </para> + <para> + Row pattern common syntax can be used to perform row pattern recognition + in a query. Row pattern common syntax includes two sub + clauses: <literal>DEFINE</literal> + and <literal>PATTERN</literal>. <literal>DEFINE</literal> defines + definition variables along with an expression. The expression must be a + logical expression, which means it must + return <literal>TRUE</literal>, <literal>FALSE</literal> + or <literal>NULL</literal>. The expression may comprise column references + and functions. Window functions, aggregate functions and subqueries are + not allowed. An example of <literal>DEFINE</literal> is as follows. + +<programlisting> +DEFINE + LOWPRICE AS price <= 100, + UP AS price > PREV(price), + DOWN AS price < PREV(price) +</programlisting> + + Note that <function>PREV</function> returns the price column in the + previous row if it's called in a context of row pattern recognition. So in + the second line the definition variable "UP" is <literal>TRUE</literal> + when the price column in the current row is greater than the price column + in the previous row. Likewise, "DOWN" is <literal>TRUE</literal> when when + the price column in the current row is lower than the price column in the + previous row. + </para> + <para> + Once <literal>DEFINE</literal> exists, <literal>PATTERN</literal> can be + used. <literal>PATTERN</literal> defines a sequence of rows that satisfies + certain conditions. For example following <literal>PATTERN</literal> + defines that a row starts with the condition "LOWPRICE", then one or more + rows satisfy "UP" and finally one or more rows satisfy "DOWN". Note that + "+" means one or more matches. Also you can use "*", which means zero or + more matches. If a sequence of rows which satisfies the PATTERN is found, + in the starting row of the sequence of rows all window functions and + aggregates are shown in the target list. Note that aggregations only look + into the matched rows, rather than whole frame. In the second or + subsequent rows all window functions and aggregates are NULL. For rows + that do not match the PATTERN, all window functions and aggregates are + shown AS NULL too, except count which shows 0. This is because the + unmatched rows are in an empty frame. Example of + a <literal>SELECT</literal> using the <literal>DEFINE</literal> + and <literal>PATTERN</literal> clause is as follows. + +<programlisting> +SELECT company, tdate, price, + first_value(price) OVER w, + max(price) OVER w, + count(price) OVER w +FROM stock, + WINDOW w AS ( + PARTITION BY company + ORDER BY tdate + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + AFTER MATCH SKIP PAST LAST ROW + INITIAL + PATTERN (LOWPRICE UP+ DOWN+) + DEFINE + LOWPRICE AS price <= 100, + UP AS price > PREV(price), + DOWN AS price < PREV(price) +); +</programlisting> +<screen> + company | tdate | price | first_value | max | count +----------+------------+-------+-------------+-----+------- + company1 | 2023-07-01 | 100 | 100 | 200 | 4 + company1 | 2023-07-02 | 200 | | | + company1 | 2023-07-03 | 150 | | | + company1 | 2023-07-04 | 140 | | | + company1 | 2023-07-05 | 150 | | | 0 + company1 | 2023-07-06 | 90 | 90 | 130 | 4 + company1 | 2023-07-07 | 110 | | | + company1 | 2023-07-08 | 130 | | | + company1 | 2023-07-09 | 120 | | | + company1 | 2023-07-10 | 130 | | | 0 +</screen> + </para> + <para> When a query involves multiple window functions, it is possible to write out each one with a separate <literal>OVER</literal> clause, but this is diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml index 7c3e940afe..1d835af15a 100644 --- a/doc/src/sgml/func.sgml +++ b/doc/src/sgml/func.sgml @@ -21878,6 +21878,7 @@ SELECT count(*) FROM sometable; returns <literal>NULL</literal> if there is no such row. </para></entry> </row> + </tbody> </tgroup> </table> @@ -21917,6 +21918,59 @@ SELECT count(*) FROM sometable; Other frame specifications can be used to obtain other effects. </para> + <para> + Row pattern recognition navigation functions are listed in + <xref linkend="functions-rpr-navigation-table"/>. These functions + can be used to describe DEFINE clause of Row pattern recognition. + </para> + + <table id="functions-rpr-navigation-table"> + <title>Row Pattern Navigation Functions</title> + <tgroup cols="1"> + <thead> + <row> + <entry role="func_table_entry"><para role="func_signature"> + Function + </para> + <para> + Description + </para></entry> + </row> + </thead> + + <tbody> + <row> + <entry role="func_table_entry"><para role="func_signature"> + <indexterm> + <primary>prev</primary> + </indexterm> + <function>prev</function> ( <parameter>value</parameter> <type>anyelement</type> ) + <returnvalue>anyelement</returnvalue> + </para> + <para> + Returns the column value at the previous row; + returns NULL if there is no previous row in the window frame. + </para></entry> + </row> + + <row> + <entry role="func_table_entry"><para role="func_signature"> + <indexterm> + <primary>next</primary> + </indexterm> + <function>next</function> ( <parameter>value</parameter> <type>anyelement</type> ) + <returnvalue>anyelement</returnvalue> + </para> + <para> + Returns the column value at the next row; + returns NULL if there is no next row in the window frame. + </para></entry> + </row> + + </tbody> + </tgroup> + </table> + <note> <para> The SQL standard defines a <literal>RESPECT NULLS</literal> or diff --git a/doc/src/sgml/ref/select.sgml b/doc/src/sgml/ref/select.sgml index 42d78913cf..522ad9dd70 100644 --- a/doc/src/sgml/ref/select.sgml +++ b/doc/src/sgml/ref/select.sgml @@ -969,8 +969,8 @@ WINDOW <replaceable class="parameter">window_name</replaceable> AS ( <replaceabl The <replaceable class="parameter">frame_clause</replaceable> can be one of <synopsis> -{ RANGE | ROWS | GROUPS } <replaceable>frame_start</replaceable> [ <replaceable>frame_exclusion</replaceable> ] -{ RANGE | ROWS | GROUPS } BETWEEN <replaceable>frame_start</replaceable> AND <replaceable>frame_end</replaceable> [ <replaceable>frame_exclusion</replaceable> ] +{ RANGE | ROWS | GROUPS } <replaceable>frame_start</replaceable> [ <replaceable>frame_exclusion</replaceable> ] [row_pattern_common_syntax] +{ RANGE | ROWS | GROUPS } BETWEEN <replaceable>frame_start</replaceable> AND <replaceable>frame_end</replaceable> [ <replaceable>frame_exclusion</replaceable> ] [row_pattern_common_syntax] </synopsis> where <replaceable>frame_start</replaceable> @@ -1077,6 +1077,40 @@ EXCLUDE NO OTHERS a given peer group will be in the frame or excluded from it. </para> + <para> + The + optional <replaceable class="parameter">row_pattern_common_syntax</replaceable> + defines the <firstterm>row pattern recognition condition</firstterm> for + this + window. <replaceable class="parameter">row_pattern_common_syntax</replaceable> + includes following subclauses. <literal>AFTER MATCH SKIP PAST LAST + ROW</literal> or <literal>AFTER MATCH SKIP TO NEXT ROW</literal> controls + how to proceed to next row position after a match + found. With <literal>AFTER MATCH SKIP PAST LAST ROW</literal> (the + default) next row position is next to the last row of previous match. On + the other hand, with <literal>AFTER MATCH SKIP TO NEXT ROW</literal> next + row position is always next to the last row of previous + match. <literal>DEFINE</literal> defines definition variables along with a + boolean expression. <literal>PATTERN</literal> defines a sequence of rows + that satisfies certain conditions using variables defined + in <literal>DEFINE</literal> clause. If the variable is not defined in + the <literal>DEFINE</literal> clause, it is implicitly assumed + following is defined in the <literal>DEFINE</literal> clause. + +<synopsis> +<literal>variable_name</literal> AS TRUE +</synopsis> + + Note that the maximu number of variables defined + in <literal>DEFINE</literal> clause is 26. + +<synopsis> +[ AFTER MATCH SKIP PAST LAST ROW | AFTER MATCH SKIP TO NEXT ROW ] +PATTERN <replaceable class="parameter">pattern_variable_name</replaceable>[+] [, ...] +DEFINE <replaceable class="parameter">definition_varible_name</replaceable> AS <replaceable class="parameter">expression</replaceable> [, ...] +</synopsis> + </para> + <para> The purpose of a <literal>WINDOW</literal> clause is to specify the behavior of <firstterm>window functions</firstterm> appearing in the query's -- 2.25.1 ----Next_Part(Sun_Oct_22_11_39_20_2023_140)-- Content-Type: Text/X-Patch; charset=us-ascii Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="v10-0006-Row-pattern-recognition-patch-tests.patch" ^ permalink raw reply [nested|flat] 4+ messages in thread
end of thread, other threads:[~2023-10-22 02:22 UTC | newest] Thread overview: 4+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2023-03-16 01:49 Re: Add macros for ReorderBufferTXN toptxn Peter Smith <[email protected]> 2023-03-16 05:10 ` Bharath Rupireddy <[email protected]> 2023-03-16 05:20 ` Amit Kapila <[email protected]> 2023-10-22 02:22 [PATCH v10 5/7] Row pattern recognition patch (docs). Tatsuo Ishii <[email protected]>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox