agora inbox for [email protected]help / color / mirror / Atom feed
[PATCH v2 1/1] pg_rewind: Fetch small files according to new size. 3+ messages / 3 participants [nested] [flat]
* [PATCH v2 1/1] pg_rewind: Fetch small files according to new size. @ 2021-01-22 13:16 Heikki Linnakangas <[email protected]> 0 siblings, 0 replies; 3+ messages in thread From: Heikki Linnakangas @ 2021-01-22 13:16 UTC (permalink / raw) There's a race condition if a file changes in the source system after we have collected the file list. If the file becomes larger, we only fetched up to its original size. That can easily result in a truncated file. That's not a problem for relation files, files in pg_xact, etc. because any actions on them will be replayed from the WAL. However, configuration files are affected. This commit mitigates the race condition by fetching small files in whole, even if they have grown. This is not a full fix: we still believe the original file size for files larger than 1 MB. That should be enough for configuration files, and doing more than that would require bigger changes to the chunking logic in in libpq_source.c. That mitigates the race condition if the file is modified between the original scan of files and copying the file, but there's still a race condition if a file is changed while it's being copied. That's a much smaller window, though, and pg_basebackup has the same issue. I ran into this while playing with pg_auto_failover, which frequently uses ALTER SYSTEM, which update postgresql.auto.conf. Often, pg_rewind would fail, because the postgresql.auto.conf file changed concurrently and a partial version of it was copied to the target. The partial file would fail to parse, preventing the server from starting up. Reviewed-by: Cary Huang Discussion: https://www.postgresql.org/message-id/f67feb24-5833-88cb-1020-19a4a2b83ac7%40iki.fi --- src/bin/pg_rewind/libpq_source.c | 32 +++++++++++++ src/bin/pg_rewind/local_source.c | 76 +++++++++++++++++++++++++++---- src/bin/pg_rewind/pg_rewind.c | 5 +- src/bin/pg_rewind/rewind_source.h | 13 ++++++ 4 files changed, 112 insertions(+), 14 deletions(-) diff --git a/src/bin/pg_rewind/libpq_source.c b/src/bin/pg_rewind/libpq_source.c index 86d2adcaee9..ff16add16f5 100644 --- a/src/bin/pg_rewind/libpq_source.c +++ b/src/bin/pg_rewind/libpq_source.c @@ -63,6 +63,7 @@ static void process_queued_fetch_requests(libpq_source *src); /* public interface functions */ static void libpq_traverse_files(rewind_source *source, process_file_callback_t callback); +static void libpq_queue_fetch_file(rewind_source *source, const char *path, size_t len); static void libpq_queue_fetch_range(rewind_source *source, const char *path, off_t off, size_t len); static void libpq_finish_fetch(rewind_source *source); @@ -88,6 +89,7 @@ init_libpq_source(PGconn *conn) src->common.traverse_files = libpq_traverse_files; src->common.fetch_file = libpq_fetch_file; + src->common.queue_fetch_file = libpq_queue_fetch_file; src->common.queue_fetch_range = libpq_queue_fetch_range; src->common.finish_fetch = libpq_finish_fetch; src->common.get_current_wal_insert_lsn = libpq_get_current_wal_insert_lsn; @@ -307,6 +309,36 @@ libpq_traverse_files(rewind_source *source, process_file_callback_t callback) PQclear(res); } +/* + * Queue up a request to fetch a file from remote system. + */ +static void +libpq_queue_fetch_file(rewind_source *source, const char *path, size_t len) +{ + /* + * Truncate the target file immediately, and queue a request to fetch it + * from the source. If the file is small, smaller than MAX_CHUNK_SIZE, + * request fetching a full-sized chunk anyway, so that if the file has + * become larger in the source system, after we scanned the source + * directory, we still fetch the whole file. This only works for files up + * to MAX_CHUNK_SIZE, but that's good enough for small configuration files + * and such that are changed every now and then, but not WAL-logged. + * For larger files, we fetch up to the original size. + * + * Even with that mechanism, there is an inherent race condition if the + * file is modified at the same instant that we're copying it, so that we + * might copy a torn version of the file with one half from the old + * version and another half from the new. But pg_basebackup has the same + * problem, and it hasn't been problem in practice. + * + * It might seem more natural to truncate the file later, when we receive + * it from the source server, but then we'd need to track which + * fetch-requests are for a whole file. + */ + open_target_file(path, true); + libpq_queue_fetch_range(source, path, 0, Max(len, MAX_CHUNK_SIZE)); +} + /* * Queue up a request to fetch a piece of a file from remote system. */ diff --git a/src/bin/pg_rewind/local_source.c b/src/bin/pg_rewind/local_source.c index 9c3491c3fba..1899d1cc4ae 100644 --- a/src/bin/pg_rewind/local_source.c +++ b/src/bin/pg_rewind/local_source.c @@ -29,8 +29,10 @@ static void local_traverse_files(rewind_source *source, process_file_callback_t callback); static char *local_fetch_file(rewind_source *source, const char *path, size_t *filesize); -static void local_fetch_file_range(rewind_source *source, const char *path, - off_t off, size_t len); +static void local_queue_fetch_file(rewind_source *source, const char *path, + size_t len); +static void local_queue_fetch_range(rewind_source *source, const char *path, + off_t off, size_t len); static void local_finish_fetch(rewind_source *source); static void local_destroy(rewind_source *source); @@ -43,7 +45,8 @@ init_local_source(const char *datadir) src->common.traverse_files = local_traverse_files; src->common.fetch_file = local_fetch_file; - src->common.queue_fetch_range = local_fetch_file_range; + src->common.queue_fetch_file = local_queue_fetch_file; + src->common.queue_fetch_range = local_queue_fetch_range; src->common.finish_fetch = local_finish_fetch; src->common.get_current_wal_insert_lsn = NULL; src->common.destroy = local_destroy; @@ -65,12 +68,65 @@ local_fetch_file(rewind_source *source, const char *path, size_t *filesize) return slurpFile(((local_source *) source)->datadir, path, filesize); } +/* + * Copy a file from source to target. + * + * 'len' is the expected length of the file. + */ +static void +local_queue_fetch_file(rewind_source *source, const char *path, size_t len) +{ + const char *datadir = ((local_source *) source)->datadir; + PGAlignedBlock buf; + char srcpath[MAXPGPATH]; + int srcfd; + size_t written_len; + + snprintf(srcpath, sizeof(srcpath), "%s/%s", datadir, path); + + /* Open source file for reading. */ + srcfd = open(srcpath, O_RDONLY | PG_BINARY, 0); + if (srcfd < 0) + pg_fatal("could not open source file \"%s\": %m", + srcpath); + + /* Truncate and open the target file for writing. */ + open_target_file(path, true); + + written_len = 0; + for (;;) + { + ssize_t read_len; + + read_len = read(srcfd, buf.data, sizeof(buf)); + + if (read_len < 0) + pg_fatal("could not read file \"%s\": %m", srcpath); + else if (read_len == 0) + break; /* EOF reached */ + + write_target_range(buf.data, written_len, read_len); + written_len += read_len; + } + + /* + * A local source is not expected to change while we're rewinding, so check + * that the size of the file matches our earlier expectation. + */ + if (written_len != len) + pg_fatal("size of source file \"%s\" changed concurrently: " UINT64_FORMAT " bytes expected, " UINT64_FORMAT " copied", + srcpath, len, written_len); + + if (close(srcfd) != 0) + pg_fatal("could not close file \"%s\": %m", srcpath); +} + /* * Copy a file from source to target, starting at 'off', for 'len' bytes. */ static void -local_fetch_file_range(rewind_source *source, const char *path, off_t off, - size_t len) +local_queue_fetch_range(rewind_source *source, const char *path, off_t off, + size_t len) { const char *datadir = ((local_source *) source)->datadir; PGAlignedBlock buf; @@ -94,14 +150,14 @@ local_fetch_file_range(rewind_source *source, const char *path, off_t off, while (end - begin > 0) { ssize_t readlen; - size_t len; + size_t thislen; if (end - begin > sizeof(buf)) - len = sizeof(buf); + thislen = sizeof(buf); else - len = end - begin; + thislen = end - begin; - readlen = read(srcfd, buf.data, len); + readlen = read(srcfd, buf.data, thislen); if (readlen < 0) pg_fatal("could not read file \"%s\": %m", srcpath); @@ -120,7 +176,7 @@ static void local_finish_fetch(rewind_source *source) { /* - * Nothing to do, local_fetch_file_range() copies the ranges immediately. + * Nothing to do, local_queue_fetch_range() copies the ranges immediately. */ } diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c index 359a6a587cb..9030a1505e3 100644 --- a/src/bin/pg_rewind/pg_rewind.c +++ b/src/bin/pg_rewind/pg_rewind.c @@ -537,10 +537,7 @@ perform_rewind(filemap_t *filemap, rewind_source *source, break; case FILE_ACTION_COPY: - /* Truncate the old file out of the way, if any */ - open_target_file(entry->path, true); - source->queue_fetch_range(source, entry->path, - 0, entry->source_size); + source->queue_fetch_file(source, entry->path, entry->source_size); break; case FILE_ACTION_TRUNCATE: diff --git a/src/bin/pg_rewind/rewind_source.h b/src/bin/pg_rewind/rewind_source.h index 2da92dbff94..799b7c120ea 100644 --- a/src/bin/pg_rewind/rewind_source.h +++ b/src/bin/pg_rewind/rewind_source.h @@ -47,6 +47,19 @@ typedef struct rewind_source void (*queue_fetch_range) (struct rewind_source *, const char *path, off_t offset, size_t len); + /* + * Like queue_fetch_range(), but requests replacing the whole local file + * from the source system. 'len' is the expected length of the file, + * although when the source is a live server, the file may change + * concurrently. The implementation is not obliged to copy more than 'len' + * bytes, even if the file is larger. However, to avoid copying a + * truncated version of the file, which can cause trouble if e.g. a + * configuration file is modified concurrently, the implementation should + * try to copy the whole file, even if it's larger than expected. + */ + void (*queue_fetch_file) (struct rewind_source *, const char *path, + size_t len); + /* * Execute all requests queued up with queue_fetch_range(). */ -- 2.29.2 --------------79EE74DA33DF3081397629A9-- ^ permalink raw reply [nested|flat] 3+ messages in thread
* Re: [PATCH] minor bug fix for pg_dump --clean @ 2022-10-24 00:12 Виктория Шепард <[email protected]> 0 siblings, 0 replies; 3+ messages in thread From: Виктория Шепард @ 2022-10-24 00:12 UTC (permalink / raw) To: Frédéric Yhuel <[email protected]>; +Cc: PostgreSQL Hackers <[email protected]> Hi, Good catch! Here are several points for improvement: 1. pg_dump.c:17380 Maybe better to write simpler appendPQExpBuffer(delcmd, "CREATE SCHEMA IF NOT EXISTS %s;\n", tbinfo->dobj.namespace->dobj.name); because there is a schema name inside the `tbinfo->dobj.namespace->dobj.name ` 2. pg_backup_archiver.c:588 Here are no necessary spaces before and after braces, and no spaces around the '+' sign. ( strncmp(dropStmt, "CREATE SCHEMA IF NOT EXISTS", 27) == 0 && strstr(dropStmt+29, "CREATE OR REPLACE VIEW") )) Best regards, Viktoria Shepard чт, 1 сент. 2022 г. в 12:13, Frédéric Yhuel <[email protected]>: > Hello, > > When using pg_dump (or pg_restore) with option "--clean", there is some > SQL code to drop every objects at the beginning. > > The DROP statement for a view involving circular dependencies is : > > CREATE OR REPLACE VIEW [...] > > (see commit message of d8c05aff for a much better explanation) > > If the view is not in the "public" schema, and the target database is > empty, this statement fails, because the schema hasn't been created yet. > > The attached patches are a TAP test which can be used to reproduce the > bug, and a proposed fix. They apply to the master branch. > > Best regards, > Frédéric ^ permalink raw reply [nested|flat] 3+ messages in thread
* [PATCH v21 2/8] Row pattern recognition patch (parse/analysis). @ 2024-08-26 04:32 Tatsuo Ishii <[email protected]> 0 siblings, 0 replies; 3+ messages in thread From: Tatsuo Ishii @ 2024-08-26 04:32 UTC (permalink / raw) --- src/backend/parser/parse_agg.c | 7 + src/backend/parser/parse_clause.c | 296 +++++++++++++++++++++++++++++- src/backend/parser/parse_expr.c | 6 + src/backend/parser/parse_func.c | 3 + 4 files changed, 311 insertions(+), 1 deletion(-) diff --git a/src/backend/parser/parse_agg.c b/src/backend/parser/parse_agg.c index bee7d8346a..9bc22a836a 100644 --- a/src/backend/parser/parse_agg.c +++ b/src/backend/parser/parse_agg.c @@ -577,6 +577,10 @@ check_agglevels_and_constraints(ParseState *pstate, Node *expr) errkind = true; break; + case EXPR_KIND_RPR_DEFINE: + errkind = true; + break; + /* * There is intentionally no default: case here, so that the * compiler will warn if we add a new ParseExprKind without @@ -967,6 +971,9 @@ transformWindowFuncCall(ParseState *pstate, WindowFunc *wfunc, case EXPR_KIND_CYCLE_MARK: errkind = true; break; + case EXPR_KIND_RPR_DEFINE: + errkind = true; + break; /* * There is intentionally no default: case here, so that the diff --git a/src/backend/parser/parse_clause.c b/src/backend/parser/parse_clause.c index 8118036495..9762dce81f 100644 --- a/src/backend/parser/parse_clause.c +++ b/src/backend/parser/parse_clause.c @@ -98,7 +98,14 @@ static WindowClause *findWindowClause(List *wclist, const char *name); static Node *transformFrameOffset(ParseState *pstate, int frameOptions, Oid rangeopfamily, Oid rangeopcintype, Oid *inRangeFunc, Node *clause); - +static void transformRPR(ParseState *pstate, WindowClause *wc, WindowDef *windef, + List **targetlist); +static List *transformDefineClause(ParseState *pstate, WindowClause *wc, WindowDef *windef, + List **targetlist); +static void transformPatternClause(ParseState *pstate, WindowClause *wc, + WindowDef *windef); +static List *transformMeasureClause(ParseState *pstate, WindowClause *wc, + WindowDef *windef); /* * transformFromClause - @@ -2956,6 +2963,10 @@ transformWindowDefinitions(ParseState *pstate, rangeopfamily, rangeopcintype, &wc->endInRangeFunc, windef->endOffset); + + /* Process Row Pattern Recognition related clauses */ + transformRPR(pstate, wc, windef, targetlist); + wc->winref = winref; result = lappend(result, wc); @@ -3820,3 +3831,286 @@ transformFrameOffset(ParseState *pstate, int frameOptions, return node; } + +/* + * transformRPR + * Process Row Pattern Recognition related clauses + */ +static void +transformRPR(ParseState *pstate, WindowClause *wc, WindowDef *windef, + List **targetlist) +{ + /* + * Window definition exists? + */ + if (windef == NULL) + return; + + /* + * Row Pattern Common Syntax clause exists? + */ + if (windef->rpCommonSyntax == NULL) + return; + + /* Check Frame option. Frame must start at current row */ + if ((wc->frameOptions & FRAMEOPTION_START_CURRENT_ROW) == 0) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("FRAME must start at current row when row patttern recognition is used"))); + + /* Transform AFTER MACH SKIP TO clause */ + wc->rpSkipTo = windef->rpCommonSyntax->rpSkipTo; + + /* Transform AFTER MACH SKIP TO variable */ + wc->rpSkipVariable = windef->rpCommonSyntax->rpSkipVariable; + + /* Transform SEEK or INITIAL clause */ + wc->initial = windef->rpCommonSyntax->initial; + + /* Transform DEFINE clause into list of TargetEntry's */ + wc->defineClause = transformDefineClause(pstate, wc, windef, targetlist); + + /* Check PATTERN clause and copy to patternClause */ + transformPatternClause(pstate, wc, windef); + + /* Transform MEASURE clause */ + transformMeasureClause(pstate, wc, windef); +} + +/* + * transformDefineClause Process DEFINE clause and transform ResTarget into + * list of TargetEntry. + * + * XXX we only support column reference in row pattern definition search + * condition, e.g. "price". <row pattern definition variable name>.<column + * reference> is not supported, e.g. "A.price". + */ +static List * +transformDefineClause(ParseState *pstate, WindowClause *wc, WindowDef *windef, + List **targetlist) +{ + /* DEFINE variable name initials */ + static char *defineVariableInitials = "abcdefghijklmnopqrstuvwxyz"; + + ListCell *lc, + *l; + ResTarget *restarget, + *r; + List *restargets; + List *defineClause; + char *name; + int initialLen; + int i; + + /* + * If Row Definition Common Syntax exists, DEFINE clause must exist. (the + * raw parser should have already checked it.) + */ + Assert(windef->rpCommonSyntax->rpDefs != NULL); + + /* + * Check and add "A AS A IS TRUE" if pattern variable is missing in DEFINE + * per the SQL standard. + */ + restargets = NIL; + foreach(lc, windef->rpCommonSyntax->rpPatterns) + { + A_Expr *a; + bool found = false; + + if (!IsA(lfirst(lc), A_Expr)) + ereport(ERROR, + errmsg("node type is not A_Expr")); + + a = (A_Expr *) lfirst(lc); + name = strVal(a->lexpr); + + foreach(l, windef->rpCommonSyntax->rpDefs) + { + restarget = (ResTarget *) lfirst(l); + + if (!strcmp(restarget->name, name)) + { + found = true; + break; + } + } + + if (!found) + { + /* + * "name" is missing. So create "name AS name IS TRUE" ResTarget + * node and add it to the temporary list. + */ + A_Const *n; + + restarget = makeNode(ResTarget); + n = makeNode(A_Const); + n->val.boolval.type = T_Boolean; + n->val.boolval.boolval = true; + n->location = -1; + restarget->name = pstrdup(name); + restarget->indirection = NIL; + restarget->val = (Node *) n; + restarget->location = -1; + restargets = lappend((List *) restargets, restarget); + } + } + + if (list_length(restargets) >= 1) + { + /* add missing DEFINEs */ + windef->rpCommonSyntax->rpDefs = + list_concat(windef->rpCommonSyntax->rpDefs, restargets); + list_free(restargets); + } + + /* + * Check for duplicate row pattern definition variables. The standard + * requires that no two row pattern definition variable names shall be + * equivalent. + */ + restargets = NIL; + foreach(lc, windef->rpCommonSyntax->rpDefs) + { + restarget = (ResTarget *) lfirst(lc); + name = restarget->name; + + /* + * Add DEFINE expression (Restarget->val) to the targetlist as a + * TargetEntry if it does not exist yet. Planner will add the column + * ref var node to the outer plan's target list later on. This makes + * DEFINE expression could access the outer tuple while evaluating + * PATTERN. + * + * XXX: adding whole expressions of DEFINE to the plan.targetlist is + * not so good, because it's not necessary to evalute the expression + * in the target list while running the plan. We should extract the + * var nodes only then add them to the plan.targetlist. + */ + findTargetlistEntrySQL99(pstate, (Node *) restarget->val, + targetlist, EXPR_KIND_RPR_DEFINE); + + /* + * Make sure that the row pattern definition search condition is a + * boolean expression. + */ + transformWhereClause(pstate, restarget->val, + EXPR_KIND_RPR_DEFINE, "DEFINE"); + + foreach(l, restargets) + { + char *n; + + r = (ResTarget *) lfirst(l); + n = r->name; + + if (!strcmp(n, name)) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("row pattern definition variable name \"%s\" appears more than once in DEFINE clause", + name), + parser_errposition(pstate, exprLocation((Node *) r)))); + } + restargets = lappend(restargets, restarget); + } + list_free(restargets); + + /* + * Create list of row pattern DEFINE variable name's initial. We assign + * [a-z] to them (up to 26 variable names are allowed). + */ + restargets = NIL; + i = 0; + initialLen = strlen(defineVariableInitials); + + foreach(lc, windef->rpCommonSyntax->rpDefs) + { + char initial[2]; + + restarget = (ResTarget *) lfirst(lc); + name = restarget->name; + + if (i >= initialLen) + { + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("number of row pattern definition variable names exceeds %d", + initialLen), + parser_errposition(pstate, + exprLocation((Node *) restarget)))); + } + initial[0] = defineVariableInitials[i++]; + initial[1] = '\0'; + wc->defineInitial = lappend(wc->defineInitial, + makeString(pstrdup(initial))); + } + + defineClause = transformTargetList(pstate, windef->rpCommonSyntax->rpDefs, + EXPR_KIND_RPR_DEFINE); + + /* mark column origins */ + markTargetListOrigins(pstate, defineClause); + + /* mark all nodes in the DEFINE clause tree with collation information */ + assign_expr_collations(pstate, (Node *) defineClause); + + return defineClause; +} + +/* + * transformPatternClause + * Process PATTERN clause and return PATTERN clause in the raw parse tree + */ +static void +transformPatternClause(ParseState *pstate, WindowClause *wc, + WindowDef *windef) +{ + ListCell *lc; + + /* + * Row Pattern Common Syntax clause exists? + */ + if (windef->rpCommonSyntax == NULL) + return; + + wc->patternVariable = NIL; + wc->patternRegexp = NIL; + foreach(lc, windef->rpCommonSyntax->rpPatterns) + { + A_Expr *a; + char *name; + char *regexp; + + if (!IsA(lfirst(lc), A_Expr)) + ereport(ERROR, + errmsg("node type is not A_Expr")); + + a = (A_Expr *) lfirst(lc); + name = strVal(a->lexpr); + + wc->patternVariable = lappend(wc->patternVariable, makeString(pstrdup(name))); + regexp = strVal(lfirst(list_head(a->name))); + + wc->patternRegexp = lappend(wc->patternRegexp, makeString(pstrdup(regexp))); + } +} + +/* + * transformMeasureClause + * Process MEASURE clause + * XXX MEASURE clause is not supported yet + */ +static List * +transformMeasureClause(ParseState *pstate, WindowClause *wc, + WindowDef *windef) +{ + if (windef->rowPatternMeasures == NIL) + return NIL; + + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("%s", "MEASURE clause is not supported yet"), + parser_errposition(pstate, exprLocation((Node *) windef->rowPatternMeasures)))); + return NIL; +} diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c index 56e413da9f..c187b3278d 100644 --- a/src/backend/parser/parse_expr.c +++ b/src/backend/parser/parse_expr.c @@ -577,6 +577,7 @@ transformColumnRef(ParseState *pstate, ColumnRef *cref) case EXPR_KIND_COPY_WHERE: case EXPR_KIND_GENERATED_COLUMN: case EXPR_KIND_CYCLE_MARK: + case EXPR_KIND_RPR_DEFINE: /* okay */ break; @@ -1860,6 +1861,9 @@ transformSubLink(ParseState *pstate, SubLink *sublink) case EXPR_KIND_GENERATED_COLUMN: err = _("cannot use subquery in column generation expression"); break; + case EXPR_KIND_RPR_DEFINE: + err = _("cannot use subquery in DEFINE expression"); + break; /* * There is intentionally no default: case here, so that the @@ -3199,6 +3203,8 @@ ParseExprKindName(ParseExprKind exprKind) return "GENERATED AS"; case EXPR_KIND_CYCLE_MARK: return "CYCLE"; + case EXPR_KIND_RPR_DEFINE: + return "DEFINE"; /* * There is intentionally no default: case here, so that the diff --git a/src/backend/parser/parse_func.c b/src/backend/parser/parse_func.c index 9b23344a3b..4c482abb30 100644 --- a/src/backend/parser/parse_func.c +++ b/src/backend/parser/parse_func.c @@ -2658,6 +2658,9 @@ check_srf_call_placement(ParseState *pstate, Node *last_srf, int location) case EXPR_KIND_CYCLE_MARK: errkind = true; break; + case EXPR_KIND_RPR_DEFINE: + errkind = true; + break; /* * There is intentionally no default: case here, so that the -- 2.25.1 ----Next_Part(Mon_Aug_26_13_39_47_2024_878)-- Content-Type: Text/X-Patch; charset=us-ascii Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="v21-0003-Row-pattern-recognition-patch-rewriter.patch" ^ permalink raw reply [nested|flat] 3+ messages in thread
end of thread, other threads:[~2024-08-26 04:32 UTC | newest] Thread overview: 3+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2021-01-22 13:16 [PATCH v2 1/1] pg_rewind: Fetch small files according to new size. Heikki Linnakangas <[email protected]> 2022-10-24 00:12 Re: [PATCH] minor bug fix for pg_dump --clean Виктория Шепард <[email protected]> 2024-08-26 04:32 [PATCH v21 2/8] Row pattern recognition patch (parse/analysis). 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